二叉树算法

前言：上篇博客写了很多关于二叉树的分类，性质，存储结构。那这篇博客要来写代码了。

 

一、创建与先序遍历

用C语言实现二叉树是很方便的，因为C语言有很高大上的指针。但，python就没有指针了，那怎么办呢? 我们可以用一个类来实现(java也是用类实现的)……

下面我创建一课二叉树，并且用先序遍历结点:

class TreeNode(object):  # 创建树的结点
    def __init__(self, node_data=None, left=None, right=None):
        self.node_data = node_data
        self.left = left
        self.right = right


class BTree(object):
    def __init__(self, root=None):  # 初始化根结点
        self.root = root

    def preorder(self, tree_node):
        if tree_node is None:
            return
        print(tree_node.node_data)
        self.preorder(tree_node.left)
        self.preorder(tree_node.right)


if __name__ == '__main__':
    n1 = TreeNode(1)
    n2 = TreeNode(2, n1)
    n3 = TreeNode(3)
    n4 = TreeNode(4)
    n5 = TreeNode(5, n3, n4)
    n6 = TreeNode(6, n2, n5)
    n7 = TreeNode(7, n6)
    n8 = TreeNode(8)

    root_node = TreeNode('root', n7, n8)  # 根结点

    bt = BTree(root_node)  # 将根结点(包含左右结点)当作参数传给BTree类

    # 前序遍历
    bt.preorder(root_node)

上面代码很重要，也很简单，看不懂可以的话就得去看看类与面向对象的知识了。首先我创建了如下的一课二叉树:

先序遍历的结果是: root-7-6-2-1-5-3-4-8

C:\Python34\python3.exe C:/Users/Administrator/PycharmProjects/laonanhai/编程/创建二叉树.py
root
7
6
2
1
5
3
4
8

Process finished with exit code 0

 

二、二叉树的遍历

遍历即将树的所有结点访问且仅访问一次。按照根节点位置的不同分为先序遍历，中序遍历，后序遍历。V表示访问根结点，L表示遍历左子树，R表示遍历右子树。

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

下面做个练习热热身: 写出上图二叉树的三种遍历方式

• 先序遍历：abdefgc
• 中序遍历：debgfac
• 后序遍历：edgfbca

很好，现在给你一课二叉树，你应该能写出三种遍历方式。啥，不懂？ 那你得多牛才进得了BAT......

我拿中序遍历来讲一下吧。中序遍历是先遍历左子树，再结点，最后右子树。以上图为例，先找根结点a的左子树b, 但b还有左子树，所以遍历的第一个数还不是b. 最后我找到了d，发现d没有左子树了，好，遍历的第一个数为结点d, 接下来为d的右子树e。e没有左右子树，所以此时以d为根结点的树已遍历完成，接下来看b的上一层，即b. b的左子树已遍历，所以遍历的第三个数为b, 接下来遍历b的右子树(以f的根结点的二叉树)，发现此时f有左子树，好极了，遍历f的左子树g，发现g结点没有左右子树，故第4个数就是g, 第5个数是g的父亲f. 接下来应该遍历f的右子树的，但f的右子树为空，b的右子树遍历完成，就直接返回上一层。此时以b为根结点的树已遍历完成。同理，接下来还需遍历a, c。最终结果是: d-e-b-g-f-a-c

遍历算法:

class TreeNode(object):  # 创建树的结点
    def __init__(self, node_data=None, left=None, right=None):
        self.node_data = node_data
        self.left = left
        self.right = right


class BTree(object):
    def __init__(self, root=None):  # 初始化根结点
        self.root = root

    def PreOrder(self, tree_node):  # 先序遍历
        if tree_node is None:
            return
        print(tree_node.node_data)
        self.PreOrder(tree_node.left)
        self.PreOrder(tree_node.right)

    def InOrder(self, tree_node):  # 中序遍历
        if tree_node is None:
            return
        self.InOrder(tree_node.left)
        print(tree_node.node_data)
        self.InOrder(tree_node.right)

    def PostOrder(self, tree_node):  # 后序遍历
        if tree_node is None:
            return
        self.PostOrder(tree_node.left)
        self.PostOrder(tree_node.right)
        print(tree_node.node_data)


if __name__ == '__main__':
    n1 = TreeNode(1)
    n2 = TreeNode(2, n1)
    n3 = TreeNode(3)
    n4 = TreeNode(4)
    n5 = TreeNode(5, n3, n4)
    n6 = TreeNode(6, n2, n5)
    n7 = TreeNode(7, n6)
    n8 = TreeNode(8)

    root_node = TreeNode('root', n7, n8)  # 根结点

    bt = BTree(root_node)  # 将根结点(包含左右结点)当作参数传给BTree类

    # 前序遍历
    print("PreOrder".center(50, "-"))
    bt.PreOrder(root_node)

    # 中序遍历
    print("InOrder".center(50, "-"))
    bt.InOrder(root_node)

    # 后序遍历
    print("PostOrder".center(50, "-"))
    bt.PostOrder(root_node)

输出:

C:\Python34\python3.exe C:/Users/Administrator/PycharmProjects/laonanhai/编程/遍历二叉树.py
---------------------PreOrder---------------------
root
7
6
2
1
5
3
4
8
---------------------InOrder----------------------
1
2
6
3
5
4
7
root
8
--------------------PostOrder---------------------
1
2
3
4
5
6
7
8
root

Process finished with exit code 0

 

三、求二叉树深度

二叉树由根结点和左、右子树构成，而根结点独占1层，所以二叉树深度为其左右子树深度的最大值加1.

利用后层遍历的思想，先递归求左、右子树的深度，然后取两者较大值　+1，作为深度值返回。

算法实现:

    def BitTreeDepth(self, tree_node):  # tree_node为结点
        if tree_node is None:  # 空二叉树深度为０
            return 0
        else:
            depth_left = self.BitTreeDepth(tree_node.left)  # 求左子树深度
            depth_right = self.BitTreeDepth(tree_node.right)  # 求右子树深度
            # 左右子树深度较大值+1
            return 1 + (depth_left if depth_left>depth_right else depth_right)

 

四、求二叉树叶子结点数

同样，我们也可以遍历左、右子树各有多少个叶子结点，一遍历到叶子结点则count++, count初始值为0.

在计算叶子结点数时，教材用C语言写的算法有用到指针，我用python写就挺懵比。后来把算法改了下，总算是搞出来了:

算法:

    def CountLeaf(self, tree_node, count):
        if tree_node is None:
            return count

        if not tree_node.left and not tree_node.right:  # 没有左右结点，即为叶子结点
            count += 1

        count = self.CountLeaf(tree_node.left, count)  # 对左子树进行递归计数
        count = self.CountLeaf(tree_node.right, count)
        return count  # 叶子数

 

 

总程序:

class TreeNode(object):  # 创建树的结点
    def __init__(self, node_data=None, left=None, right=None):
        self.node_data = node_data
        self.left = left
        self.right = right


class BTree(object):
    def __init__(self, root=None):  # 初始化根结点
        self.root = root

    def PreOrder(self, tree_node):  # 先序遍历
        if tree_node is None:
            return
        print(tree_node.node_data)
        self.PreOrder(tree_node.left)
        self.PreOrder(tree_node.right)

    def InOrder(self, tree_node):  # 中序遍历
        if tree_node is None:
            return
        self.InOrder(tree_node.left)
        print(tree_node.node_data)
        self.InOrder(tree_node.right)

    def PostOrder(self, tree_node):  # 后序遍历
        if tree_node is None:
            return
        self.PostOrder(tree_node.left)
        self.PostOrder(tree_node.right)
        print(tree_node.node_data)

    def BitTreeDepth(self, tree_node):  # tree_node为结点
        if tree_node is None:  # 空二叉树深度为０
            return 0
        else:
            depth_left = self.BitTreeDepth(tree_node.left)  # 求左子树深度
            depth_right = self.BitTreeDepth(tree_node.right)  # 求右子树深度
            # 左右子树深度较大值+1
            return 1 + (depth_left if depth_left>depth_right else depth_right)

    def CountLeaf(self, tree_node, count):
        if tree_node is None:
            return count

        if not tree_node.left and not tree_node.right:  # 没有左右结点，即为叶子结点
            count += 1

        count = self.CountLeaf(tree_node.left, count)  # 对左子树进行递归计数
        count = self.CountLeaf(tree_node.right, count)
        return count  # 叶子数


if __name__ == '__main__':
    n1 = TreeNode(1)
    n2 = TreeNode(2, n1)
    n3 = TreeNode(3)
    n4 = TreeNode(4)
    n5 = TreeNode(5, n3, n4)
    n6 = TreeNode(6, n2, n5)
    n7 = TreeNode(7, n6)
    n8 = TreeNode(8)

    root_node = TreeNode('root', n7, n8)  # 根结点

    bt = BTree(root_node)  # 将根结点(包含左右结点)当作参数传给BTree类

    print("\033[31;1m二叉树已创建完成\033[0m".center(50, "-"))

    while True:
        print("""\033[31;1m
            1.遍历二叉树
            2.求二叉树的深度
            3.求二叉树叶子结点数
            exit.退出\033[0m
        """)
        choice = input("\033[31;1m please choose:\033[0m")
        if choice == "1":
            print("开始遍历二叉树".center(50, "-"))
            # 前序遍历
            print("PreOrder".center(50, "-"))
            bt.PreOrder(root_node)
            # 中序遍历
            print("InOrder".center(50, "-"))
            bt.InOrder(root_node)
            # 后序遍历
            print("PostOrder".center(50, "-"))
            bt.PostOrder(root_node)
        elif choice == "2":
            # 求二叉树的深度
            depth = bt.BitTreeDepth(root_node)
            print("\033[31;1m depth:\033[0m", depth)
        elif choice == "3":
            # 求二叉树叶子结点数
            leaf_count = bt.CountLeaf(root_node, count=0)  # 叶子数为０，当作参数传入
            print("\033[31;1m leaf_count\033[0m", leaf_count)
        elif choice == "exit":
            exit()
        else:
            print("\033[31;1mPlease input value num\033[0m")
            continue

二叉树示意图:

运行结果:

C:\Python34\python3.exe C:/Users/Administrator/PycharmProjects/laonanhai/编程/遍历二叉树.py
---------------二叉树已创建完成----------------

            1.遍历二叉树
            2.求二叉树的深度
            3.求二叉树叶子结点数
            exit.退出
        
 please choose:1
---------------------开始遍历二叉树----------------------
---------------------PreOrder---------------------
root
7
6
2
1
5
3
4
8
---------------------InOrder----------------------
1
2
6
3
5
4
7
root
8
--------------------PostOrder---------------------
1
2
3
4
5
6
7
8
root

            1.遍历二叉树
            2.求二叉树的深度
            3.求二叉树叶子结点数
            exit.退出
        
 please choose:2
 depth: 5

            1.遍历二叉树
            2.求二叉树的深度
            3.求二叉树叶子结点数
            exit.退出
        
 please choose:3
 leaf_count 4

            1.遍历二叉树
            2.求二叉树的深度
            3.求二叉树叶子结点数
            exit.退出
        
 please choose:exit

Process finished with exit code 0