算法备忘录（python3）

如果你使用的是Chrome，可以试试Ctrl+F搜索你想要找的内容！

数组

a = []
a.append() #在后面添加
b = a.pop() #删除最后一个,并把最后一个返回给b

链表

class Node(object):
    def __init__(self, data):
        self.data = data
        self.next = None

栈

stack = []
stack.append() #栈添加
last = stack.pop() #栈删除，并把删除元素返回

队列

queue = []
queue.insert(0,data) #队列添加
data= queue.pop() #队列删除，并把删除元素返回

双端队列

from collections import deque
deq = deque()
deq.append() #右侧添加
deq.appendleft() #左侧添加
data = deq.pop() #右侧删除
data = deq.popleft() #左侧删除

#使用双端队列实现栈
stack = deque()
stack.append() #添加
data = stack.pop() #删除

#使用双端队列实现队列
queue = deque()
queue.append() #添加
data = queue.popleft() #删除

优先队列

from queue import PriorityQueue
pd = PriorityQueue()
pd.put(value, priority) #添加，1级别最高
data = pd.get() #取出最高级

哈希表和映射

dic = {
   'a': 12, 'b': 23}
dic['c'] = 34 #添加
data = dic.get('a') #获得，如果不存在则返回None
dic.pop('a') #删除

集合

s = set() #创建一个无序不重复元素集,查询时间为O(1)
s.add(data) #添加
s.remove(data) #删除

二叉树

class TreeNode:
	def __init__(self, val=0, left=None, right=None):
		self.val = val
		self.left = left
		self.right = right

递归

def recursion(level, param1, param2, ...):
	#递归终止条件
	if level > MAX_LEVEL:
		result.append() #result添加和处理
		return
	#当前层的逻辑处理部分
	
	...

	#进入下一层
	recursion(level+1, param1, param2, ...)

	#返回当前层状态
	return	

分治

def divide_conquer(problem, param1, param2, ...):
	#分治终止条件
	if problem is None:
		return value
	#当前层的逻辑处理部分
	data = prepare_data(problem)
	subs = split_problem(problem, data)
	#进入下一层计算子问题
	sub1 = divide_conquer(subs[0], param1, param2, ...)
	sub2 = divide_conquer(subs[1], param1, param2, ...)
	sub3 = divide_conquer(subs[2], param1, param2, ...)
	...
	#最终结果计算
	result = process_result(sub1, sub2, sub3, ...)
	return	result 

回溯

def backtracking(item = 0):
	#回溯终止条件
	if item == len(LIST):
		return True
	#当前层的逻辑处理部分
	index = prepare_index(item)
	#回溯
	for f in OUTSIDE_LIST(index):
		#改变result
		change_result(result)
		#进入下一层