Python【C++常用STL相关内容】

Python【C++常用STL相关内容】

最近呢在备战蓝桥杯，但是刷题的过程中，发现之前一直用C++的STL，现在有些功能不太熟悉，并且Python的时间效率实在是太低了，所以整理一下C++中的STL在Python中对应的知识点。

1.栈(LifoQueue)

import queue
# Python的LifoQueue相当于C++STL的stack
# 后入队者先出队，入参 maxsize 是一个整数，用于设置队列的最大长度。
# 一旦队列达到上限，插入数据将会被阻塞，直到有数据出队列之后才可以继续插入。
# 如果 maxsize 设置为小于或等于零，则队列的长度没有限制。

# 创建LifoQueue
sta = queue.LifoQueue()
# 使用put()可以往栈中压入元素
sta.put(1)
sta.put(3)
sta.put(2)
# 使用empty()可以判断栈是否为空
# 使用get()可以弹出并且返回栈顶元素
while not sta.empty():
    print(sta.get())

输出：

2
3
1

2.队列(Queue)

import queue
# Python的Queue相当于C++STL的queue
# 先进先出队列，入参 maxsize 是一个整数，用于设置队列的最大长度。
# 一旦队列达到上限，插入数据将会被阻塞，直到有数据出队列之后才可以继续插入。
# 如果 maxsize 设置为小于或等于零，则队列的长度没有限制。

# 定义了一个Queue
q = queue.Queue()
# 使用put可以将元素入队
q.put(1)
q.put(3)
q.put(2)
# 使用qsize()可以查看队列的元素个数
print(q.qsize())
# 使用empty()可以查看队列是否为空
# 使用get()可以弹出并且返回队列的队头元素
while not q.empty():
    print(q.get())

输出：

3
1
3
2

3.字典(dict)

# 使用dict()可以创建一个新的字典
d = dict()
# 使用d[x]=y可以添加一个键值对x:y
# 如果x已经存在那么就将该x对应的值修改为y
# 该操作的时间复杂度为O(1)
d[1] = "hello"
d[2] = "python"
d[2]= "Python"
print(d)
# 使用del d[x]可以将键为x的对从字典d中删除
# 如果字典中不存在该键，那么会报错
# 该操作的时间复杂度为O(1)
del d[1]
print(d)
# 使用len(d)可以查看字典中键值对的个数
print(len(d))
# 使用x in d可以判断键x是否在d中存在
# 时间复杂度为O(1)
if 2 in d:
    del d[2]
print(d)
# 此外还可以对字典进行遍历或者复制操作
# 时间复杂度为O(n)
# 使用clear可以清空字典
# 使用del d可以删除字典d

输出：

{1: 'hello', 2: 'Python'}
{2: 'Python'}
1
{}

4.集合(set)

# 使用set()可以创建一个空的集合
s = set()

# 使用add()可以往集合中添加元素
# 其时间复杂度平均为O(1)，最坏的情况是O(n)
s.add(1)
s.add(1)
s.add(1)
s.add(2)
s.add(2)
s.add(3)
s.add(4)
print(s)

# 使用 x in s可以判断值x是否在集合s中
# 其时间复杂度平均为O(1)，最坏的情况是O(n)
# 使用remove(x)可以将值x从集合中删除
# 其时间复杂度平均为O(1)，最坏的情况为O(n)
if 1 in s:
    s.remove(1)
print(s)

# 集合的运算
t = set([1,2,3])
print(t)
# 使用s - t可以得到两个集合的差
# 其时间复杂度为O(len(s))
print(s - t)
# 使用s & t可以得到两个集合的交集
# 其时间复杂度为O(min(len(s),len(t)))
print(s & t)
# 使用s | t可以得到两个集合的并集
print(s | t)
# 使用s ^ t可以得到不同时在两个集合的元素
print(s ^ t)
print('---------------------')

# 如果要添加的元素布不止一个，那么可以用update方法将列表、元组、字典添加到集合中
ss = set()
ss.add(1)
print(ss)
ss.update([1,2,3,4])
print(ss)
# 如果要删除的内容不在集合中，用remove会出现报错
# 这时候可以使用discard来删除
ss.remove(1)
ss.discard(1)
print(ss)
# 使用len可以查看集合中元素的个数
print(len(ss))
# 拷贝集合可以用copy
sss = ss.copy()
print(sss)
# 使用clear可以清空集合
ss.clear()
print(ss)
print(sss)

输出：

{1, 2, 3, 4}
{2, 3, 4}
{1, 2, 3}
{4}
{2, 3}
{1, 2, 3, 4}
{1, 4}
---------------------
{1}
{1, 2, 3, 4}
{2, 3, 4}
3
{2, 3, 4}
set()
{2, 3, 4}

5.堆(heapq)

import heapq        # 引入

# 堆的特性是最小的元素在根节点 heap[0]访问

# 创建一个堆，可以用[]
q1 = []
q2 = [5,3,2,4,1]
# 或者用heapify把一个list转换成堆，原地，线性时间内
heapq.heapify(q2)

# heapq.heappush(a,b) 将b加入到堆a中
# 将某个值加入heap中
heapq.heappush(q1,3)    # 往q1中加入3
heapq.heappush(q2,3)    # 往q2中加入3
heapq.heappush(q1,4)    # 往q1中加入4
heapq.heappush(q2,4)    # 往q2中加入4
heapq.heappush(q1,0)    # 往q1中加入0
heapq.heappush(q2,0)    # 往q2中加入0

# heapq.heappop(a) 弹出并返回堆a中最小的元素
# 打印堆两种方式
while q1:
    print(q1[0],end=' ')
    heapq.heappop(q1)
print()
while q2:
    print(heapq.heappop(q2),end=' ')
print()

# heapq.heappushpop(a,b) 将b放入堆a中，再弹出并返回a中最小的元素
# 该方法比先heappush(b) 再heappop(a)运行起来更有效率
heapq.heappush(q1,2)
heapq.heappush(q1,5)
heapq.heappush(q1,6)
heapq.heappushpop(q1,4)
print(q1)       # 直接print堆输出的不是按从小到大的顺序输出的，而是按这个列表的内容输出的

# heapq.nlargest(n,q,key=None) 返回堆q中前n个最大值，key指定单参数
# heapq.nsmallest(n,q,key=Node) 返回堆q中前n个最小值，key指定单参数
print(heapq.nlargest(2,q1))
print(heapq.nsmallest(2,q1))

输出：

0 3 4 
0 1 2 3 3 4 4 5 
[4, 5, 6]
[6, 5]
[4, 5]

6.优先队列(PriorityQueue)

import queue
# Python的PriorityQueue相当于C++STL的priority_queue
# 后入队者先出队，入参 maxsize 是一个整数，用于设置队列的最大长度。
# 一旦队列达到上限，插入数据将会被阻塞，直到有数据出队列之后才可以继续插入。
# 如果 maxsize 设置为小于或等于零，则队列的长度没有限制。

# 创建PriorityQueue
pq = queue.PriorityQueue()
# 使用put()可以往优先队列中压入元素
pq.put(1)
pq.put(3)
pq.put(2)
# 使用empty()可以判断栈是否为空
# 使用get()可以弹出并且返回栈顶元素
while not pq.empty():
    print(pq.get())

pq2 = queue.PriorityQueue()
pq2.put([1,10,100])
pq2.put([3,100,0])
pq2.put([4,-10,-10])
while not pq2.empty():
    print(pq2.get())

输出：

1
2
3
[1, 10, 100]
[3, 100, 0]
[4, -10, -10]

7.二分查找(bisect)

import bisect       # import二分库

arr = [1,4,5,3,2,4,5,6,2,3,8]
arr.sort()
print(arr)
# bisect.bisect(a,x,lo = 0,hi = len(a))
# a是需要查找的数组，x是需要查找的值，lo是区间开始位置，hi是区间结束位置的后一个位置
# 默认查找的区间是整个a，返回值是x能插入到arr的合适位置（需要保证插入后arr增减不变）
print(bisect.bisect(arr,7))
# 如果arr中存在了一个或者多个x了，返回的是所以等于x的值的最右边的下一位
print(bisect.bisect(arr,1))
print(bisect.bisect(arr,2))
# 如果需要看最左边是在哪个地方，那就使用bisect.bisect_left(arr,x)
# 同样也有bisect.bisect_right(arr,x)效果和bisect.bisect(arr,x)一样
print(bisect.bisect_left(arr,1))
print(bisect.bisect_left(arr,2))
# 如果我们需要查找一个数在有序列表中最早出现的位置，那么就直接使用bisect.bisect_left()
# 如果我们需要查找一个数在有序列表中最后出现的位置，那么就直接使用bisect.bisect_right()
# 如果我们要查找的数可能不在该有序列表中，那么就对查找的下标进行判断是否等于要查询的这个数，
# 如果不相等，那就说明该有序列表中不存在这个数

# 同时bisect还提供了插入操作，插入一个值过后继续维持有序，
# 但是时间复杂度是O(n)，所以就不用考虑这种操作了，可以考虑用堆

输出：

[1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 8]
10
1
3
0
1