常用算法与数据结构（python实现）

快速排序

#考虑数据[1,3,5,7,4,6,2]
def partition(arr,low,high):
    #以arr[low]为基准将数组划分为两个部分
	key = arr[low]
	while low < high:
		#从右往左边扫，注意等号
		while low < high and arr[high] >= key:
			high -=1
		arr[low] = arr[high]
		#从左往右扫，注意等号
		while low < high and arr[low] <= key:
			low +=1
		arr[high] = arr[low]
	#找到key应该属于的位置并返回坐标
	arr[low] = key
	return low

def quick_sort(arr,low,high):
	#注意判断语句
	if low < high:
		pivot = partition(arr,low,high)
		quick_sort(arr,low,pivot-1)
		quick_sort(arr,pivot+1,high)
	return arr

if __name__ == '__main__':
	arr = [1,3,5,7,4,6,2,2]
	low = 0
	high = len(arr)-1
	arr_sorted = quick_sort(arr,low,high)
	print(arr_sorted)

二叉树的前序中序后续遍历（递归与非递归实现）

#二叉树前序遍历(递归法)
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        ans = []
        self.recursive(root,ans)
        return ans
        
    def recursive(self,root,ans):
        if root == None:
            return
        ans.append(root.val)
        self.recursive(root.left,ans)
        self.recursive(root.right,ans)
        
#二叉树前序遍历(非递归法)
class Solution:
    def preorderTraversal(self, root: TreeNode) -> List[int]:
        ans,stack = [],[]
        while root or stack:
            if root:
                ans.append(root.val)
                stack.append(root)
                root = root.left
            else:
                root = stack.pop()
                root = root.right
        return ans

#二叉树的中序遍历(递归法)
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if root == None:
            return []
        ans = []
        self.dfs(root,ans)
        return ans
        
    def dfs(self,root,ans):
        if root == None:
            return
        self.dfs(root.left,ans)
        ans.append(root.val)
        self.dfs(root.right,ans)
        
#二叉树中序遍历(非递归法)
#规律为：当前结点curr不为None时，每一次循环将当前结点curr入栈,且往左指；
#当前结点curr为None时，则出栈一个结点，且打印出栈结点的value值，往右节点走
#整个循环在stack和curr皆为None的时候结束。
class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        ans,stack = [],[]
        while root or stack:
            if root:
                stack.append(root)
                root = root.left
            else:
                root = stack.pop()
                ans.append(root.val)
                root = root.right
        return ans

#二叉树后序遍历（递归法）
class Solution:
	def postorderTraversal(self,root:TreeNode)->List[int]:
		if root == None:
			return []
		ans = []
		self.dfs(root,ans)
		return ans
	def dfs(self,root,ans):
		if root == None:
			return
		self.dfs(root,ans)
		self.dfs(root,ans)
		ans.append(root.val)

#二叉树后序遍历（非递归法）
class Solution:
	def postorderTraversal(self,root:TreeNode)->List[int]:
		if root == None:
			return []
		ans,stack = [],[root]
		while stack:
			root = stack.pop()
			if root.left:
				stack.append(root.left)
			if root.right:
				stack.append(root.right)
			ans.append(root.val)
		ans = ans[::-1]
		return ans

DP算法

Github总结地址