Python3 common data structure

1. list

1.1 Initialize List & Add Modified Elements

if __name__ == '__main__':

    #初始化一个长度为3 默认值为0的列表
    arr1 = [0] * 7

    #初始化一个空的列表 空列表如果向其添加元素只能使用append()
    arr0 = []

    #赋值(修改)元素
    arr1[0] = 1
    arr1[1] = 2
    arr1[2] = 3
    arr1[3] = 4
    arr1[4] = 3
    arr1[5] = 5
    arr1[6] = 6

    print("arr1初始值： {}".format(arr1))

    # 继续添加元素
    # arr1[7] = 7
    # 注意：这种方式是错误的，因为我们指定了arr1的初始长度为7，所以索引最大为6，
	
    #追加元素 使用append()
    arr1.append(7)

    print("arr1 追加一个元素7后: {}".format(arr1))
	
# 打印    
# arr1初始值： [1, 2, 3, 4, 3, 5, 6]
# arr1 追加一个元素7后: [1, 2, 3, 4, 3, 5, 6, 7]

1.2 Delete elements

    # pop(idx)方法 按照索引删除元素，默认删除末尾的元素并返回
    x = arr1.pop()
    y = arr1.pop()
    print("arr1.poo() 删除末尾两个元素后: {}".format(arr1))
	
    #remove(x)方法 删除列表中从左到右第一个x元素
    arr1.remove(3)
    print("arr1.remove 删除第一个元素3后: {}".format(arr1))
	
    #根据索引删除
    del arr1[0]
    print("del arr1 删除索引为0的元素后: {}".format(arr1))

# 打印
# arr1.poo() 删除末尾两个元素后: [1, 2, 3, 4, 3, 5]
# arr1.remove 删除第一个元素3后: [1, 2, 4, 3, 5]
# del arr1 删除索引为0的元素后: [2, 4, 3, 5]   

1.3 Other common methods

#将列表b中的元素全部添加到列表a中 (Java中的addAll())
a = [1, 3, 5]; b = [2, 4, 6]
a.extend(b)
print(a) #[1, 3, 5, 2, 4, 6]
# 注意：不能使用append()，使用append()那么b会当做一个列表会添加到a中. 
# 就会变成[1, 3, 5, [2, 4, 6]]

#统计x元素在列表中出现的次数
cnt = list.count(x)

#判断元素x是否在列表中出现过
f = x in list 

#返回列表中的最小值
min_v = min(list)
#返回列表中的最大值
max_v = max(list)

#找出元素x在列表中第一次出现的位置 注意：不存在报错 所以使用之前先判断是否存在
idx = list.index(x)

#反转列表
list.reverse()

#排序 默认从小到大(普通类型)
list.sort()

#加上reverse参数，从大到小排序
list.sort(reverse = True)

#判断两个列表的元素是否相同 借助operatot模块的eq方法
a = [1, 2]
b = [2, 3]
print(operator.eq(a, b)) # False

#遍历
  #通过索引遍历  
    for i in range(len(list)): print(list[i])
  #类似Java增强for循环遍历
    for x in list: print(x)

1.4 Custom sorting

class Pair:
    f = 0
    s = 0

    def __init__(self, f, s):
        self.f = f
        self.s = s
	
    #类似Java的toString()方法
    def __str__(self):
        return "{} -- {}".format(self.f, self.s)


if __name__ == '__main__':

    p1 = Pair(1, 22)
    p2 = Pair(2, 21)
    p3 = Pair(3, 223)
    p4 = Pair(3, 32)
    p5 = Pair(4, 21)

    a = []
    a.append(p1)
    a.append(p2)
    a.append(p3)
    a.append(p4)
    a.append(p5)
	
    #sorted()不改变原序列 key：按照某个属性排序 False默认从小到大排序
    sorted(a, key=lambda p: p.f, reverse=False)
	
    #改变原序列 按照Pair的s属性排序,False从小到大排序
    a.sort(key=lambda p: p.s, reverse=False)
	
    for x in a:
        print(x)

1.5 Two-dimensional array

python是没有专门的二维数组的，我们可以使用列表的嵌套当做二维数组(列表)使用

if __name__ == '__main__':

    # 创建一个4行3列的二维数组
    a = [[0] * 3] * 4

    # m行数 n列数
    m = len(a)
    n = len(a[0])

    # 赋值
    for i in range(m):
        for j in range(n):
            a[i][j] = 1

    # 遍历
    for i in range(m):
        for j in range(n):
            print(a[i][j], end=" ")
        print()

2. stack

Generally we use Python3 lists as stacks

stk = []

#入栈(将元素添加到最后)
stk.append()

#出栈(删除最后一个元素)
stk.pop()

3. Collection

if __name__ == '__main__':
	
    #根据一个列表创建一个集合
    a = [1, 2, 3, 3, 4, 3, 5]
    S3 = set(a)
    
    #创建一个空集合
    S = set()

    #向集合中添加元素
    S.add(1)
    S.add(1)
    S.add(2)
    S.add(3)
	
    #向集合中添加列表中的元素，
    S.update([1, 2, 3], [2, 3, 4])
    
    #判断x是否存在集合中 (x in set)
    f = 4 in S

    #移除元素 不存在报错
    S.remove(11)
    
    #移除元素 不存在不会报错
    S.discard(2)

    #遍历
    for x in S:
        print(x)

4. Dictionary

if __name__ == '__main__':

    # 创建一个空的字典
    map = dict()

    # 添加|修改元素 map[key] = value
    map[1] = 2
    map[2] = 2
    map[3] = 2
    map[4] = 3
	
	#添加键值对，当key不存在时设置默认值 
	map.setdefault(9, 0)	

    # 根据key删除键值对
    map.pop(1)

    # 根据key删除键值对
    del map[2]
	
    # 根据key获取value，注意key不存在时报错
    x = map[3]
	
    # 根据key获取value,key不存在时不报错
    map.get(1)

    # 重载方法 根据key获取value，如果key不存在返回默认值 map.get(key, default_val)
    map.get(9, 12)

    # 将字典中的所有key取出并转换成一个列表
    keys = list(map.keys())

    # 将字典中的所有value取出并转换成一个列表
    values = list(map.values())

    # 判断key为x的键值对是否存在于字典中
    f = 3 in map

    #获取字典中所有的键值对
    items = map.items()
	
    #遍历每一个键值对
    for k, v in map.items():
        print(k, "---", v) 

5. (Double-ended) queue

from collections import deque

if __name__ == '__main__':
    
    #创建一个空的双端队列
    q = deque()

#第一种组合，尾进头出    
    
    # 队列末尾进
    q.append(1)
    q.append(2)
    q.append(3)
    
    # 队列头出
    x = q.popleft()
    y = q.popleft()
    z = q.popleft()

#--------------------------------------------------------

#第二种组合，头进尾出

    #队头进
    q.appendleft(1)
    q.appendleft(2)
    q.appendleft(3)

    #队尾出
    x = q.pop()
    y = q.pop()
    z = q.pop()

    
#---------------作为栈使用-----------------------------------------
    
#当然，双端队列，每一端都可以作为栈使用
# append() + pop() 尾进尾出
# appendleft() + popleft() 头进头出

7. Priority queue

使用heapq操作

Leetour.347 Top K high-frequency elements

class Solution:
    def topKFrequent(self, nums: List[int], n: int) -> List[int]:
        import heapq    
        heap = []; ans = []
        map = dict()
        for x in nums:
            map.setdefault(x, 0) # x不存在设置默认值为0
            map[x] += 1 
        
        #将元素添加到堆中，优先级根据次数排列，
        for k, v in map.items():
            heapq.heappush(heap, (-v, k)) 
        
        for i in range(len(heap)):
            if n == 0: return ans
            v, k = heapq.heappop(heap) #弹出堆顶元素 
            ans.append(k); n -= 1
        return ans

Lituo 23. Merge K ascending linked lists

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next

class Solution:
    def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:
        import heapq
        dummy = ListNode(0); cur = dummy
        heap = []
        
        #将链表头加入堆中，值越小优先级越高 
        for i in range(len(lists)):
            if lists[i]: heapq.heappush(heap, (lists[i].val, i)) 
        
        while heap:
            val, idx = heapq.heappop(heap) #弹出队头元素，取出下标
            node = lists[idx]; cur.next = node; cur = cur.next
            if node.next: 
                heapq.heappush(heap, (node.next.val, idx))
                lists[idx] = lists[idx].next 
                
        return dummy.next