一、什么是数组

连续内存空间，存储的一组相同类型的元素

二、常用操作

1.原理

access：通过索引直接读取元素的值

时间复杂度：O(1)

search：遍历查找某个元素

时间复杂度：O(N)

insert：插入位置后的元素依次后移，空出插入空间，插入新元素

时间复杂度：O(N)

delete：删除指定位置元素，后面的元素依次向前补位

时间复杂度：O(N)

2.实现

#创建空list，控制每个元素类型相同
a=[]

#添加元素
a.append(1)
a.append(2)
a.append(3)

print(a)
#[1,2,3]

#insert,O(n)
a.insert(2,99)

#access
print(a[2])
#99

#update
a[2]=88
print(a)
#[1,2,88,3]

#delete
a.remove(88) #O(N)
a.pop(1) #delete a[1],O(N)
a.pop() #delete last,O(1)
print(a)
#[1]

#get array size
print(len(a))
#1

#iterate array, O(N)
for i in a:
    print(i) #1
for index, e in enumerate(a):
    print(index,e) #0，1
for i in range(0,len(a)):
    print(i,a[i]) #0,1

#find index
print(a.index(1))
#0

#sort an array
a.sort
a.sort(reverse=True)

Leetcode练习

1056.易混淆数

给定一个数字 N，当它满足以下条件的时候返回 true：

原数字旋转 180° 以后可以得到新的数字。

如 0, 1, 6, 8, 9 旋转 180° 以后，得到了新的数字 0, 1, 9, 8, 6 。

2, 3, 4, 5, 7 旋转 180° 后，得到的不是数字。

易混淆数 (confusing number) 在旋转180°以后，可以得到和原来不同的数，且新数字的每一位都是有效的。

class Solution(object):
    def confusingNumber(self, n):
        #index:0,1,2,3,4,5,6,7,8,9
        con_arr=[0,1,-1,-1,-1,-1,9,-1,8,6]
        digit_list = [int(d) for d in str(n)]
        n_len=len(digit_list)
        renum=['']*n_len
        #inerate num
        for i in range(0,n_len):
            if con_arr[digit_list[i]] !=-1:
                renum[n_len-1-i]=con_arr[digit_list[i]]
            else: 
                return False
        res = int(''.join(str(d) for d in renum))
        if res == n:
            return False
        return True

1427. 字符串的左右移

给定一个包含小写英文字母的字符串 s 以及一个矩阵 shift，其中 shift[i] = [direction, amount]：

direction 可以为 0 （表示左移）或 1 （表示右移）。
amount 表示 s 左右移的位数。
左移 1 位表示移除 s 的第一个字符，并将该字符插入到 s 的结尾。
类似地，右移 1 位表示移除 s 的最后一个字符，并将该字符插入到 s 的开头。

对这个字符串进行所有操作后，返回最终结果。

class Solution(object):
    def stringShift(self, s, shift):
        """
        :type s: str
        :type shift: List[List[int]]
        :rtype: str
        """
        s_len=len(s)
        res_s=['']*s_len
        if s_len ==1:
            return s
        for sl in shift:
            if sl[1]>s_len: sl[1]= sl[1]%s_len
            #left: index before amount move to last, left move forward
            if sl[0] ==0:
                for i in range(0,s_len):
                    if i<sl[1]:
                        res_s[s_len-sl[1]+i]=s[i]
                    else:
                        res_s[i-sl[1]]=s[i]
            #right: index after len-1-amount move to begin, left move backward
            else:
                pos=s_len-sl[1]
                for j in range(0,s_len):
                    if j<pos:
                        res_s[j+sl[1]]=s[j]
                    else:
                        res_s[sl[1]-(s_len-j)]=s[j]
            s=''.join(res_s)
        return ''.join(res_s)