python算法二叉树总结整理

整理B站视频教程：https://www.bilibili.com/video/BV1TV41177uv?p=1

内容：

　　（1）N个结点不同二叉树的个数

　　（2）二叉树的创建

　　（3）遍历二叉树

　　（4）二叉树的深度

　　（5）拷贝二叉树

　　（6）二叉树实际应用--二叉搜索树

一、N个节点不同二叉树的个数

　　N个结点可以构成多少不同的二叉树？

　　分析：n个结点，其中一定有一个是根结点（root）；另外的n-1个结点在根结点的左子树或者右子树，然后左子树看作根结点，又有不同的左右个数分配……

假设n=4，那么除去根结点还有3个结点，可以是根结点左边0个结点、右边3个节点，或者根结点左边1个结点，或者左边两个结点，或者左边3个结点；而每一次左边有多个结点时,第三层结点分布又有不同的排列组合……

　　假设n个结点，左边有k个结点，则右边有n-1-k个结点。设左边k个结点的组合方式为cl,右边结点的组合方式为cr,所以共有的组合方式：cl*cr

　　python代码实现：

# def count(n):
#     # root :1
#     # left :k   [0,n-1]
#     #right :n-k-1
#     if n == 0:
#         return 1
#     s = 0
#     for k in range(n):
#         s += count(k) * count(n-k-1)
#     return s
#=========================================加入缓存机制，可以超级快的提高计算速度，因为属于迭代算法，每一次计算都要去先算前面n的值，所以加入缓存可以将之前算的都存下来==================
def count(n):
    # root :1
    # left :k   [0,n-1]
    #right :n-k-1
    # if n == 0:
    #     return 1    #直接将n=0,s=1这种情况加入字典
    s = count.cache.get(n,0)
    if s:
        return s  #如果s不是0，直接返回
    # s = 0 #s = count.cache.get(n,0)的意思就是，如果缓存cache中有n，那么就将n赋值给s,如果缓存cache中没有n，那么就将缓存的默认参数0赋值给s
#            所以，上面的代码就已经将s=0的可能考虑在内了
    for k in range(n):
        s += count(k) * count(n-k-1)
        count.cache[n] = s #将新计算的n和对应的S加入缓存字典
    return s
count.cache = {0:1}  #创建一个缓存，用于存储已经计算过的n，默认情况，n=0时，s=1
print(count(100))

二、创建二叉树

　　分析：创建二叉树，其实就是先创建结点，然后给各个结点建立父子或者兄弟关系；采用python中的类来创建结点，利用构造器来给这个类初始化

　　python代码实现：

 

class TreeNode(object):
    def __init__(self,data,left = None, right = None):   #初始化结点，因为左右结点都可能为空，所以默认设置左右结点的值为空，如果没有传入左右结点就是空，有的话则是传入的结点
        self.data = data        #这个结点需要有数值
        self.left = left         #这个结点可能有左结点
        self.right = right        #这个结点可能有右结点

    def __str__(self):             #对结点数值输出做的改进，输出结点的时候，自动输出为结点的数值，也就是不用写C.right.data中的data
        return (str(self.data))
#============================调用TreeNode类来创建结点
# A = TreeNode("A")
# B = TreeNode("B")
# C = TreeNode("C")
# D = TreeNode("D",left=A) #上面的A、B、C只是构造出来，并没有给他们赋予左右子结点，构造D的时候就直接在复制时将A作为D的左结点
# E = TreeNode('E')
# E.left = B #在构造E的时候并没有给E的左结点赋值，只是构造出来，但是可以通过后期给E.left赋值
A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI'] #利用列表迭代的方法创建独立结点
#=================================给各个结点之间创建联系=============================
A.left = B
A.right = C
B.right = D
C.left = E
C.right = F
E.left = G
F.left = H
F.right = I
# print(C.right.data) #输出测试，输出C的右结点的值，也就是F，但是可以做改进，不用写data
print(C.right)

三、遍历二叉树

　　遍历二叉树也就是二叉树的每一个结点都要访问到，根据遍历的顺序，分为先序遍历、中序遍历、后序遍历和层序遍历；先序遍历：根左右；中序遍历：左根右；后续遍历：左右根；层序遍历：每一层自左向右。

（1）先序遍历

　　分析：遍历的过程先遍历传入的根结点root,然后递归的遍历根结点的左结点作为根结点的子树，然后递归的遍历根结点的右结点作为根结点的子树；整个递归的结束条件，应该是这个根结点不再有左右结点。

代码实现：

from TreeNode import TreeNode
def creatTree():
    A, B, C, D, E, F, G, H, I = [TreeNode(X) for X in 'ABCDEFGHI']  # 利用列表迭代的方法创建独立结点
        # =================================给各个结点之间创建联系=============================
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A

def preOrder(node):
    if node is None:
        return
    print(node.data)
    preOrder(node.left)
    preOrder(node.right)

if __name__ == '__main__':
    root = creatTree()
    preOrder(root)

（2）中序遍历

　　分析：和先序遍历斯思想一样，但是不是先输出根结点，而是先递归的找到左结点

　　python代码实现：

from TreeNode import TreeNode
def creatTree():
    A, B, C, D, E, F, G, H, I = [TreeNode(X) for X in 'ABCDEFGHI']  # 利用列表迭代的方法创建独立结点
        # =================================给各个结点之间创建联系=============================
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
#===============先序遍历==========================================
# def preOrder(node):
#     if node is None:
#         return
#     print(node.data)
#     preOrder(node.left)
#     preOrder(node.right)

#================中序遍历===========================================
def inOrder(node):
    if node is None:
        return
    inOrder(node.left)
    print(node.data)
    inOrder(node.right)

if __name__ == '__main__':
    root = creatTree()
    # preOrder(root)
    inOrder(root)

（3）后序遍历

　　分析：思路和先序一样，但是是先递归找到树的左结点和右结点，然后是根

　　python代码实现：

from TreeNode import TreeNode
def creatTree():
    A, B, C, D, E, F, G, H, I = [TreeNode(X) for X in 'ABCDEFGHI']  # 利用列表迭代的方法创建独立结点
        # =================================给各个结点之间创建联系=============================
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
#===============先序遍历==========================================
# def preOrder(node):
#     if node is None:
#         return
#     print(node.data)
#     preOrder(node.left)
#     preOrder(node.right)

#================中序遍历===========================================
# def inOrder(node):
#     if node is None:
#         return
#     inOrder(node.left)
#     print(node.data)
#     inOrder(node.right)
#================后序遍历===========================================
def postOrder(node):
    if node is None:
        return
    postOrder(node.left)
    postOrder(node.right)
    print(node.data)

if __name__ == '__main__':
    root = creatTree()
    # preOrder(root)
    # inOrder(root)
    postOrder(root)

（4）回溯迭代版本的先序

　　分析：前面的思路是迭代版本，还可以通过回溯的方法实现。回溯首先需要有一个栈，用来存储遍历的根结点，每次都去找左结点找根结点，一直到根为0，就应该弹出最后的根结点然后访问这个结点的右结点，将右结点作为新的根。回溯结束的条件应该是栈为空，也就是说，等到所有的都抛出去，也就是所有的右结点也都访问到了，此时结束。

　　python代码实现：

from TreeNode import TreeNode


def creatOrder():
    A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI']
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
def preOrder(node):
    s = []
    while True:
        while node:
            print(node)
            s.append(node)
            node = node.left
        if not s:
            break
        node = s.pop().right
if __name__ == "__main__":
    root = creatOrder()
    preOrder(root)

（5）层序遍历

　　分析：层序遍历是指按着一层一层去遍历结点，可以采用队列的方式进行，每次遍历根据出队的结点顺序。先是父结点入队，然后父结点出队的时候子节点入队，保证父结点始终在子节点前面，而且子节点入队的时候也是左边的子节点先入队，保证出队先左节点后右结点。等到队列为空的时候，也就是所有结点都遍历到了。

　　python代码实现：

from collections import deque

from TreeNode import TreeNode


def creatTree():
    A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI']
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
def levelOrder(node):
    q = deque([node])
    while q:
        node = q.popleft() #父结点先出队
        print(node)
        if node.left:
            q.append(node.left) #如果有左结点，左结点入队
        if node.right:
            q.append(node.right)

if __name__ == '__main__':
    root = creatTree()
    levelOrder(root)

四、树的深度

（1）递归方法计算

　　分析：计算树的深度，就是子节点中深度的最大值加1，求每个子节点的深度的时候，又递归的分为子节点深度最大值加1.

　　python代码实现：

from TreeNode import TreeNode


def creatTree():
    A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI']
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
def deep(node):
    if node is None:
        return 0
    dl = deep(node.left)
    dr = deep(node.right)
    dp = max(dl,dr) + 1
    return dp
if __name__ == '__main__':
    root = creatTree()
    print(deep(root))

（2）迭代 方法计算

　　分析：思考层序遍历的方法思路，在进行层序遍历的时候，最后一个出队的结点也就在最深一层，所有只要知道最后一个出队的结点的深度也就知道整个树的深度。所以在向队中存储结点的时候，需要把这个结点的深度也存进去，那就可以用一个元祖包含结点值和结点深度。

　　python代码实现：

from collections import deque

from TreeNode import TreeNode


def creatTree():
    A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI']
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
def deep(node):
    if node is None:
        return 0
    dl = deep(node.left)
    dr = deep(node.right)
    dp = max(dl,dr) + 1
    return dp
#================================================以迭代的方式计算深度============================================
def deep2(node):
    q = deque([(node,1)]) #以元祖的形式来表示结点的值和深度
    while q:
        (node,d) = q.popleft()
        if node.left:
            q.append((node.left,d+1)) #前面抛出过程中，抛出的d是父结点的深度，给子节点赋值深度的时候就需要在父结点深度的基础上加1
        if node.right:
            q.append((node.right,d+1))
    return d
if __name__ == '__main__':
    root = creatTree()
    print(deep2(root))

五、树的拷贝

　　分析：采用递归的思想，先拷贝左子树和右子树，然后创建根结点，在创建根结点时将拷贝到的左右子树赋值给创建的结点

　　python代码实现：

from collections import deque

from TreeNode import TreeNode
def creatTree():
    A,B,C,D,E,F,G,H,I = [TreeNode(X) for X in 'ABCDEFGHI']
    A.left = B
    A.right = C
    B.right = D
    C.left = E
    C.right = F
    E.left = G
    F.left = H
    F.right = I
    return A
def treeCopy(node):
    if node is None:
        return None
    cl = treeCopy(node.left)
    cr = treeCopy(node.right)
    node = TreeNode(node.data,cl,cr)
    return node
def levelOrder(node):
    q = deque([node])
    while q:
        node = q.popleft() #父结点先出队
        print(node)
        if node.left:
            q.append(node.left) #如果有左结点，左结点入队
        if node.right:
            q.append(node.right)
if __name__ == "__main__":
    root = creatTree()
    new_Tree = treeCopy(root)
    levelOrder(new_Tree)

六、树的实际应用-二叉搜索树

　　包括二叉树的搜索（search）和插入（insert）

　　分析：二叉树的搜索，类似与二分法的搜索，每次将要搜索的值与父结点比较，在父结点不为空以及父结点的值和要搜索的值不相等的情况下，比较父结点的值和要搜索的值大小关系，小于父结点，则将左结点取作父结点，否则将右结点取作父结点。对搜索进行改进可以有利于插入算法，改进就是在原来返回结点基础上返回该结点的父结点。

　　　　二叉树的插入，调用改进的搜索算法，先利用搜索算法检索二叉树中是否有这个值，如果有，那么不必插入，直接返回，停止操作；如果没有，那么就创建一个数值等于要插入数的结点，然后，如果这是一个空树，直接将该结点作为二叉树的根结点，如果不是空树，根据改进的搜索算法是返回值中的parent值，搜索返回值中node = None,但是parent返回的是最接近K值的一个结点，所以只需要比较K值和父结点数值的大小：K<父结点数值，将新结点插入到父结点左侧，否则插入到父结点右侧

　　python代码实现：

from TreeNode import TreeNode
from levelOrder import levelOrder,creatTree
class BinarySearchTree():
    def __init__(self):
        self.root = None
#======================搜索算法=====================
    def search(self,k):
        node = self.root
        while node != None and k != node.data:
            if k < node.data:
                node = node.left
            else:
                node = node.right
        return node
#=====================改进的搜索算法,不止找到这个数所在的结点，也找到该结点的子结点==================
    def _search(self,k):
        parent = None
        node = self.root
        while node and k != node.data:
            parent = node
            if k < node.data:
                node = node.left
            else:
                node = node.right
        return node ,parent
#=====================插入算法，调用了改进的搜索算法=================================================
    def insert(self,k):
        node,parent = self._search(k)
        if node:
            return  #如果node有值，也就意味着在原本的树的结构中含有要插入的这个值，直接返回，不必进行插入操作了

        node = TreeNode(k) #创建一个新的结点，这个结点的数值为k，这个结点的左右结点都为空
        if parent is None:
            self.root = node  # 考虑极端情况，假设是一个空树，每一项都是空，那么查找的时候查找的父结点自然也是空，这时直接将要插入的数作为这个树的根结点即可
        # 在调用搜索函数查找的过程中，虽然没有找到和K匹配的结点，但是父结点就已经是和这个k值最接近的结点，只需要根据k值和父结点的大小就行比较，确定将新结点作为父结点的左结点还是右结点即可
        elif k < parent.data:
            parent.left = node
        else:
            parent.right = node

if __name__ == '__main__':
    # root = creatTree()
    bst = BinarySearchTree() #只是创建了一个二叉树类
    bst.insert(10)
    bst.insert(5)
    bst.insert(15)
    levelOrder(bst.root)