python刷题-STL应用（c++）

补充，print() 参数的解释

sep参数 – 用来间隔多个对象，默认值是一个空格
end参数 – 用来设定以什么结尾。默认值是换行符 \n，我们可以换成其他字符串；“end=’ '”意思是末尾不换行，加空格。
file参数 – 要写入的文件对象。
flush参数 – 输出是否被缓存通常决定于 file，但如果 flush 关键字参数为 True，流会被强制刷新。

一、 数组 list()

python中 list()默认可以添加任何数据类型进入数组
C++则需要提前声明

声明列表的五种方式：（l4，l5比较快）

l1 = []
for i in range(1000): l1.append(i)

l2 = []
for i in range(1000): l2 += [i]

l3 = [0 for _ in range(1000)]

l4 = [0]*1000

l5 = list(range(1000))

方法：

• pop(): O(1)
• pop(i): O(n)
• insert(i, item): O(n)
• in list() -> bool: O(n) 包含
• list()[2:4] -> list(): 数据切片
• list().index(2, 1, 3) ->list: 返回序列s从1开始到3位置中第一次出现元素2的位置，不存在产生ValueError异常
• list().count(12): 返回 list 中出现12的总次数
• list(),reverse(): 反转列表
• list().extend(list()): 两个列表合并

举例

print(10 in l1)  # True
print(0 not in l1)  # False

二、字符串 str()

三、队列 from queue import Queue

方法：

• 入队：Queue().put()
• 出队：Queue().get()
• 是否为空：Queue.empty()
• 队列size： Queue.qsize()

使用list模拟

# queue: 使用list模拟队列
q = []  # 定义队列
q.append(4)  # 入队  [4]
q.append(3)  # 入队  [4, 3]
q.append(7)  # 入队  [4, 3, 7]
q.pop(0)  # 队首出队  [3, 7]`

四、优先队列，PriorityQueue与heap （默认小顶堆）

• PriorityQueue， 基于类的实现
• heap ，基于函数方法实现，在原数组上修改（速度更快）

注意：该方法 只能保证 堆顶元素为最小值

from queue import PriorityQueue

from queue import PriorityQueue
heap = PriorityQueue()
heap.put((2, 'hi'))
heap.put((1, 'hello'))
heap.put((3, 'world'))

print(heap.queue) # 输出堆中所有元素 [(1, ‘hello’), (2, ‘hi’), (3, ‘world’)]
print(heap.queue[0]) # 输出堆顶元素, 不删除 (1, ‘hello’)
print(heap.get()) # 输出堆顶元素, 并删除堆顶元素(1, ‘hello’)
print(heap.qsize()): 2

python3中不能向PriorityQueue添加参数变为大顶堆，

• 方法1：自己封装一个，
• 方法2：插入 负值

import heapq
class MaxHeap(object):
    def __init__(self, x):
        self.heap = [-e for e in x]
        heapq.heapify(self.heap)
    def put(self, value):
        heapq.heappush(self.heap, -value)
    def get(self):
        return -heapq.heappop(self.heap)

import heap as hp （将list转换为等价的优先队列）

heapify(nums: List[int])->None ：保证 堆顶为最小值， $O(N)$
如要实现堆排序，则需借助 heappop，$O(Nlog(N))$

import heapq as hq
nums = [3,2,4,7,2,4,88,90,4]
hq.heapify(nums)
# [2, 2, 4, 4, 3, 4, 88, 90, 7]
cur = hq.heappop(nums)
# [2, 3, 4, 4, 7, 4, 88, 90]
hq.heappop(nums)
hq.heappush(nums, 1)
# [1, 2, 4, 3, 7, 4, 88, 90, 4]

五、栈 stack

1. (list 模拟栈)

stk = []
stk.append(20)  # 入栈
stk.append(10)
stk.append(30)
stk.pop(len(stk) - 1)  # 出栈
stk.pop() # 出栈，会返回值
stk.clear()  # 清空栈
print(len(stk))  # 获取栈中元素个数  0
print(len(stk) == 0)  # 判断栈是否为空  True

2. 自己构造一个class Stack

class Stack:
    def __init__(self):
        self.items = []
    
    def empty(self): return self.items==[]
    
    def push(self, item): self.items.append(item)
    
    def pop(self): return self.items.pop()
    
    def top(self):  #return self.items[self.size()] 越界
    	return self.items[self.size()-1]
    
    def size(self): return len(self.items)

六、双端队列 from collections import deque

from collections import deque
# 定义 deque
d = deque()

• 插入、删除元素
  d.append(20) # 队尾插入一个元素 deque([20])
  d.append(10) # 队尾插入一个元素 deque([20, 10])
  d.pop() # 弹出一个尾部数据 deque([20])
  d.appendleft(40) # 队首插入一个元素 deque([40, 20])
  d.appendleft(30) # 队首插入一个元素 deque([30, 40, 20])
  d.popleft() # 弹出一个队首数据 deque([40, 20])
• 遍历

for x in d:
    print(x, end=", ") # end 是print（）的参数

• 返回队首和队尾元素
  print(d[0]) # 队首元素 40
  print(d[len(d) - 1]) # 队尾元素 20
• 清空 deque

d.clear()
print(len(d))  # 0
print(len(d) == 0)  # True 

七、有序集合 from sortedcontainers import SortedSet (类似于c++ 的set)

1. 升序set

from sortedcontainers import SortedSet
ss = SortedSet([3, 1, 2, 5, 4])
print(ss)  # SortedSet([1, 2, 3, 4, 5])

2. 降序set

from operator import neg
ss1 = SortedSet([3, 1, 2, 5, 4], neg)
print(ss1)  # SortedSet([5, 4, 3, 2, 1], key=<built-in function neg>)

3. SortedSet 转为 list/tuple/set

print(list(ss))  # SortedSet转为list    [1, 2, 3, 4, 5]
print(tuple(ss))  # SortedSet转为tuple    (1, 2, 3, 4, 5)
print(set(ss))  # SortedSet转为set    {1, 2, 3, 4, 5}

4. 插入、删除元素

ss.discard(-1)  # 删除不存在的元素不报错
ss.remove(1)  # 删除不存在的元素报错, KeyError
ss.discard(3)  # SortedSet([1, 2, 4, 5])
ss.add(-10)  # SortedSet([-10, 1, 2, 4, 5])

5. 返回第一个和最后一个元素

类似于c++的 set.begin(); --set.end()

print(ss[0])  # -10
print(ss[-1])  # 5

6. 遍历 set

for e in ss:
    print(e, end=", ")  # -10, 2, 4, 5,
print()

7. set 中判断某元素是否存在

print(2 in ss) # True

8. bisect_left() / bisect_right() 二分搜索

print(ss.bisect_left(4))  # 返回大于等于4的最小元素对应的下标    2
print(ss.bisect_right(4))  # 返回大于4的最小元素对应的下标    3
# 清空 set
ss.clear()
print(len(ss))  # 0
print(len(ss) == 0)  # True`

八、无序集合 set() （类似于unordered_set）

两种定义：

A = {"hi", 2, ("we", 24)}
B = set()  # 空集合的定义，不能使用B = {}定义集合，这样是字典的定义

1. 无序集合间的操作, 下面的运算法符都可以写成 op= 的形式

print("---------------------------------------")
S = {1, 2, 3}
T = {3, 4, 5}
print(S & T)  # 交集，返回一个新集合，包括同时在集合S和T中的元素
print(S | T)  # 并集，返回一个新集合，包括在集合S和T中的所有元素
print(S - T)  # 差集，返回一个新集合，包括在集合S但不在T中的元素
print(S ^ T)  # 补集，返回一个新集合，包括集合S和T中的非相同元素
# 集合的包含关系
print("---------------------------------------")
C = {1, 2}
D = {1, 2}
print(C <= D)  # C是否是D的子集  True
print(C < D)  # C是否是D的真子集  False
print(C >= D)  # D是否是C的子集  True
print(C > D)  # D是否是C的真子集  False

2. 无序集合的处理方法

print("---------------------------------------")
S = {1, 2, 3, 5, 6}
S.add(4)  # 如果x不在集合S中，将x增加到S
S.discard(1)  # 移除S中元素x，如果x不在集合S中，不报错
S.remove(2)  # 移除S中元素x，如果x不在集合S中，产生KeyError异常
for e in S:  # 遍历
    print(e, end=",")
print()
print(S.pop())  # 从S中随机弹出一个元素，S长度减1，若S为空产生KeyError异常
print(S.copy())  # 返回集合S的一个副本, 对该副本的操作不会影响S
print(len(S))  # 返回集合S的元素个数
print(5 in S)  # 判断S中元素x， x在集合S中，返回True，否则返回False
print(5 not in S)  # 判断S中元素x， x在集合S中，返回True，否则返回False
S.clear()  # 移除S中所有元素 

九、有序可重复集合，from sortedcontainers import SortedList， 类似于 multiset

"""
网址：http://www.grantjenks.com/docs/sortedcontainers/sortedlist.html
"""
from sortedcontainers import SortedList
# 定义
sl = SortedList(key=lambda x: -x)  # 降序
sl = SortedList([3, 1, 2, 1, 5, 4])  # 升序
print(sl)  # SortedList([1, 1, 2, 3, 4, 5])
# 插入、删除元素
sl.add(3)
sl.add(3)
sl.discard(2)  # SortedList([1, 1, 3, 3, 3, 4, 5])
print(sl)
# 统计某个元素出现的次数
print(sl.count(3))  # 3
# 返回第一个和最后一个元素
print(sl[0])  # 1
print(sl[-1])  # 5
# 遍历 set
for e in sl:
    print(e, end=", ")  # 1, 1, 3, 3, 3, 4, 5,
print()
# 判断某元素是否存在
print(2 in sl)  # False
# bisect_left() / bisect_right()
print(sl.bisect_left(3))  # 返回大于等于3的最小元素对应的下标    2
print(sl.bisect_right(3))  # 返回大于3的最小元素对应的下标    5
# 清空
sl.clear()
print(len(sl))  # 0
print(len(sl) == 0)  # True

十、有序map，from sortedcontainers import SortedDict, 相当于cpp的map

from sortedcontainers import SortedDict
sd = SortedDict()
# 插入、删除元素
sd["wxx"] = 21
sd["hh"] = 18
sd["other"] = 20
print(sd)  # SortedDict({'hh': 18, 'other': 20, 'wxx': 21})
print(sd["wxx"])  # 访问不存在的键会报错, KeyError
print(sd.get("c"))  # 访问不存在的键会返回None     None

# SortedDict转dict
print(dict(sd))  # {'hh': 18, 'other': 20, 'wxx': 21}
# 返回最后一个元素和最后一个元素
print(sd.peekitem(0))  # 类型tuple, 返回第一个元素    ('hh', 18)
print(sd.peekitem())  # 类型tuple, 返回最后一个元素    ('wxx', 21)

# 遍历
for k, v in sd.items():
    print(k, ':', v, sep="", end=", ")  # sep取消每行输出之间的空格
print()
for k in sd:  # 遍历键k, 等价于for k in d.keys:
    print(str(k) + ":" + str(sd[k]), end=", ")
print()
for v in sd.values():  # 遍历值v
    print(v, end=", ")
print()

# 返回Map中的一个键
print(sd.peekitem()[0])
# 返回Map中的一个值
print(sd.peekitem()[1])
# 中判断某元素是否存在
print("wxx" in sd)  # True

1. bisect_left() / bisect_right() 二分查找

sd["a"] = 1
sd["c1"] = 2
sd["c2"] = 4
print(sd)  # SortedDict({'a': 1, 'c1': 2, 'c2': 4, 'hh': 18, 'other': 20, 'wxx': 21})
print(sd.bisect_left("c1"))  # 返回键大于等于"c1"的最小元素对应的下标    1
print(sd.bisect_right("c1"))  # 返回键大于"c1"的最小元素对应的下标    2

# 清空
sd.clear()
print(len(sd))  # 0
print(len(sd) == 0)  # True 

十一、无序字典 from collections imort defaultdict，相当于cpp的unordered_map

注意这里于dict(), {}的不同，dict不能访问不存在的元素，
而collections.defaultdict可以，默认生成一个None

# 字典树
Trie = lambda: collections.defaultdict(Trie) 
trie = Trie()


# 普通字典
d = {"c1": 2, "c2": 4, "hh": 18, "wxx": 21, 13: 14, 1: 0}
d2 = dict()

print(d["wxx"])  # 21
print(d[13])  # 14
d[13] += 1
print(d[13])  # 15
d["future"] = "wonderful"  # 字典中添加键值对

del d[1]  # 删除字典d中键1对应的数据值
print("wxx" in d)  # 判断键"wxx"是否在字典d中，如果在返回True，否则False
print(d.keys())  # 返回字典d中所有的键信息  dict_keys(['c1', 'c2', 'hh', 'wxx', 13])
print(d.values())  # 返回字典d中所有的值信息  dict_values([2, 4, 18, 21, 14])
print(d.items())  # dict_items([('c1', 2), ('c2', 4), ('hh', 18), ('wxx', 21), (13, 14)])

for k, v in d.items():  # 遍历 k, v
    print(k, ':', v)
for k in d:  # 遍历键k, 等价于for k in d.keys:
    print(str(k) + ":" + str(d[k]), end=", ")
print()

for v in d.values():  # 遍历值v
    print(v, end=", ")
print()

# 字典类型操作函数和方法
print("---------------------------------------")
d = {"中国": "北京", "美国": "华盛顿", "法国": "巴黎"}
print(len(d))  # 返回字典d中元素的个数  3
print(d.get("中国", "不存在"))  # 键k存在，则返回相应值，不在则返回<default>值  北京
print(d.get("中", "不存在"))  # 不存在
print(d.get("中"))  # None
d["美国"] = "Washington"  # 修改键对应的值
print(d.pop("美国"))  # 键k存在，则返回相应值，并将其从dict中删除
print(d.popitem())  # 随机从字典d中取出一个键值对，以元组形式返回，并将其从dict中删除
d.clear()  # 删除所有的键值对