本文记录下在使用刷Leetcode的一些记录，主要使用变成语言为Python3。

tree的定义：

Python中二叉树的定义

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

其他编程语言常见的定义：

内存模型：

二叉树分类

1. 满二叉树(Full Binary Tree)

除最后一层无任何子节点外，每一层上的所有结点都有两个子结点二叉树，如下图：

2. 完全二叉树（Complete Binary Tree）

如果一棵二叉树有n个结点，深度为k，它的每一个结点都与高度为k的满二叉树中编号为1~n的结点一一对应，则称该树为完全二叉树。如下图：

3. 平衡二叉树(Balanced Binary Tree)

平衡二叉树又称AVL树，平衡二叉树是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。如下图：

4.二叉搜索树

二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；它的左、右子树也分别为二叉排序树。如下图：

常用算法操作

通用模板

## 1个root
def slove(root):
    if not root: return xxxx
    if f(root): return yyyy
    l = slove(root.left)
    r = slove(root.right)
    return g(root, l, r)
    
## 2个root    
def slove(p, q):
    if not p and not q: return xxxx
    if f(p, q): reutn yyyy
    c1 = slove(p.child, q.child)
    c2 = slove(p.child, q.child)
    return g(p, q, c1, c2)

三种遍历

常见的遍历有先序遍历，中序遍历，后序遍历。

先序遍历：根节点->左子树->右子树
中序遍历：左子树->根节点->右子树
后序遍历：左子树->右子树->根节点

先序遍历

def preorder(root):
    if not root: return 
    print(root.val)
    preorder(root.left)
    preorder(root.right)

中序遍历

def inorder(root):
    if not root: return
    inorder(root.left)
    print(root.val)
    inorder(root.right)

后序遍历

def postorder(root):
    if not root: return
    postorder(root)
    postorder(root)
    print(root.val)

创建二叉搜索树(BST)

根据一个nums数组，创建一个BST

class TreeNode:
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
    
    
def createBST(nums):
    root = None
    for num in nums:
        root = insert(root, num)
    return root    
    
def insert(root, val):
    # 注意 这个二叉树不是平衡的
    if not root: return TreeNode(val)
    if val <= root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root
    
def inorder(root):
    if not root: return
    inorder(root.left)
    print(root.val)
    inorder(root.right)

def inorder_list(root):
    # 得到中序遍历的数组
    res = []
    if not root: return []
    res.append(root.val)
    res.extend(inorder_list(root.left))
    res.extend(inorder_list(root.right))
    return res


if __name__ == "__main__":
    nums = [5,1,4,2,3,6]
    root = createBST(nums)
    inorder(root)

上面的代码执行结果为：

找到二叉树的最大值

def maxVal(root):
    max_left = maxVal(root.left)
    max_right = maxVal(root.right)
    return max(root.val, max_left, max_right)

最大深度

leetcode 104

def maxDeep(root):
    if not root: return 0
    l = maxDeep(root.left)
    r = maxDeep(root.right)
    return max(l, r) + 1

最小深度

leetcod 111

def minDeep(root):
    if not root: return 0
    if not root.leght and root.right return 1
    l = minDeep(root.left)
    r = minDeep(root.right)
    if not root.left: return 1 + r
    if not root.right: return 1 + l # 1 + left
    return max(l, r) + 1

BFS

    def bfs(root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """
        res = []
        from Queue import Queue
        queue = Queue()
        queue.put(root)
        while (not queue.empty()):
            temp = Queue()
            row = []
            while(not queue.empty()):
                node = queue.get()
                if node:
                    row.append(node.val)
                    if node.left:
                        temp.put(node.left)
                    if node.right:    
                        temp.put(node.right)
            queue = temp        
            res.append(row)       
        return res

创建一个平衡的BST

class Solution(object):
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        def sortedBST(nums, start, end):
            if start > end: return None
            mid = (start + end) // 2
            root = TreeNode(nums[mid])
            root.left = sortedBST(nums, start, mid-1)
            root.right = sortedBST(nums, mid+1, end)
            return root
        
        if not nums: return None
        return sortedBST(nums, 0, len(nums)-1)

BFS和DFS

def BFS(root):
# 使用列表作为队列
    queue = []
    # 将首个根节点添加到队列中
    queue.append(root)
    # 当队列不为空时进行遍历
    while queue:
    # 从队列头部取出一个节点并判断其是否有左右节点
    # 若有子节点则把对应子节点添加到队列中，且优先判断左节点
        temp = queue.pop(0)
        left = temp.left
        right = temp.right
        if left:
            queue.append(left)
        if right:
            queue.append(right)
        print(temp.val,end=" ")

def DFS(root):
# 使用列表作为栈
    stack = []
    # 将首个根节点添加到栈中
    stack.append(root)
    # 当栈不为空时进行遍历
    while stack:
    # 从栈的末尾弹出一个节点并判断其是否有左右节点
    # 若有子节点则把对应子节点压入栈中，且优先判断右节点
        temp = stack.pop()
        left = temp.left
        right = temp.right
        if right:
            stack.append(right)
        if left:
            stack.append(left)
        print(temp.val,end=" ")

# 定义节点类
class Node(object):
    def __init__(self,val,left=None,right=None):
        self.val = val
        self.left = left
        self.right = right
        
# 创建树模型
node = Node("A",Node("B",Node("D"),Node("E")),Node("C",Node("F"),Node("G")))

print("BFS",end=" ")
BFS(node)
print("")
print("DFS",end=" ")
DFS(node)

引用

文章中的视截图来自youtube 博主花花,感谢博主的视频。本文的参考的youtube 视频链接