Python二叉树实现和遍历

1. 树的基本概念

若一个结点有子树，那么该结点称为子树根的"双亲"，子树的根是该结点的"孩子"。有相同双亲的结点互为"兄弟"。一个结点的所有子树上的任何结点都是该结点的后裔。从根结点到某个结点的路径上的所有结点都是该结点的祖先。

结点的度：结点拥有的子树的数目。
叶子：度为零的结点。
分支结点：度不为零的结点。
树的度：树中结点的最大的度。

层次：根结点的层次为1，其余结点的层次等于该结点的双亲结点的层次加1。
树的高度：树中结点的最大层次。
无序树：如果树中结点的各子树之间的次序是不重要的，可以交换位置。
有序树：如果树中结点的各子树之间的次序是重要的, 不可以交换位置。
森林：0个或多个不相交的树组成。对森林加上一个根，森林即成为树；删去根，树即成为森林。

2. 二叉树

二叉树（Binary Tree）是一种特殊的树型结构，它的特点是每个结点至多有两棵子树（即二叉树中不存在度大于2的结点），且二叉树的子树有左右之分，其次序不能任意颠倒（有序树）。

2.1 二叉树的遍历顺序

先序遍历的操作定义为：若二叉树为空，为空操作；否则（1）访问根节点；（2）先序遍历左子树；（3）先序遍历右子树。
中序遍历的操作定义为：若二叉树为空，为空操作；否则（1）中序遍历左子树；（2）访问根结点；（3）中序遍历右子树。
后序遍历的操作定义为：若二叉树为空，为空操作；否则（1）后序遍历左子树；（2）后序遍历右子树；（3）访问根结点。
层序遍历的操作定义为：若二叉树为空，为空操作；否则从上到下、从左到右按层次进行访问。

以此二叉树为例
       E
     /    \
    A      G
     \       \
      C       F
    /  \
   B    D

前序遍历结果：EACBDGF
中序遍历结果：ABCDEGF
后序遍历结果：BDCAFGE
层次遍历结果：EAGCFBD

2.2 二叉树的链式存储

将二叉树的结点定义为一个对象，结点之间通过类似链表的链接方式来连接。
结点定义：

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left  # 左子树
        self.right = right  # 右子树

3.完整的Python代码如下：

from collections import deque
"""
实现一个二叉树， 并进行遍历
        E
     /    \
    A      G
     \      \
     C       F
   /  \
  B    D
"""

class Node:
    def __init__(self, value, left=None, right=None):
        self.value = value
        self.left = left  # 左子树
        self.right = right  # 右子树

def preTraverse(root):
    """
    前序遍历
    :param root:
    :return:
    """
    if root is None:
        return
    print(root.value, end=' ')
    preTraverse(root.left)
    preTraverse(root.right)

def midTraverse(root):
    """
    中序遍历
    :param root:
    :return:
    """
    if root is None:
        return
    midTraverse(root.left)
    print(root.value, end=' ')
    midTraverse(root.right)

def afterTraverse(root):
    """
    后序遍历
    :param root:
    :return:
    """
    if root is None:
        return
    afterTraverse(root.left)
    afterTraverse(root.right)
    print(root.value, end=' ')

def levelTravel(root):
    """
    层次遍历，使用队列实现
    :param root:
    :return:
    """
    queue = deque()
    queue.append(root)  # 先把根添加到队列中
    while len(queue):  # 队列不为空
        node = queue.popleft()
        print(node.value, end=' ')
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)


if __name__ == '__main__':
    # 初始化结点
    a = Node("A")
    b = Node("B")
    c = Node("C")
    d = Node("D")
    e = Node("E")
    f = Node("F")
    g = Node("G")
    # 结点之间的关系
    e.left = a
    e.right = g
    a.right = c
    c.left = b
    c.right = d
    g.right = f
    # 根结点
    root = e
    # 前序遍历
    print("***前序遍历结果***")
    preTraverse(root)
    # 中序遍历
    print("\n")
    print("***中序遍历结果***")
    midTraverse(root)
    # 后序遍历
    print("\n")
    print("***后序遍历结果***")
    afterTraverse(root)
    # 层次遍历
    print("\n")
    print("***层次遍历结果***")
    levelTravel(root)

运行结果：

***前序遍历结果***
E A C B D G F 

***中序遍历结果***
A B C D E G F 

***后序遍历结果***
B D C A F G E 

***层次遍历结果***
E A G C F B D 
Process finished with exit code 0