数据结构与算法之二叉树的Python简单实现

二叉树的存储结构

1、顺序存储结构
按从上到下，从左到右顺序存储将二叉树各结点存储在连续数组中。

2、链式存储结构
采用链表形式存储二叉树中的各结点，用链建立各结点之间的关系。
二叉树最常用的链式存储结构是二叉链，每个结点包含三个域，分别是数据元素域data、左孩子链域left和右孩子链域right。
用Python类来定义一个二叉树的结点：

class TreeNode(object):
    def __init__(self, data, left=None, right=None):
        self.data = data # 元素值
        self.left = left # 左子树根结点
        self.right = right # 右子树根结点

定义二叉树：

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

生成二叉树：

    node6 = TreeNode(6)
    node5 = TreeNode(5)
    node4 = TreeNode(4)
    node3 = TreeNode(3, node6)
    node2 = TreeNode(2, node4, node5)
    node1 = TreeNode(1, node2, node3)

    BT = BTree(node1)

对象BT即为如下结构的二叉树：

     1
   /   \
  2     3
 / \   / 
4   5 6   

---

二叉树遍历

由二叉树的递归遍历定义，一颗非空二叉树由根结点N，左子树L和右子树R组成。
遍历二叉树则是按不同的顺序访问这三部分：
1、访问根结点N
2、遍历该根结点左子树L
3、遍历该根结点右子树R
遍历方式分为：前序遍历(NLR)、中序遍历(LNR)、后序遍历(LRN)。

Python实现

为上文定义的二叉树BTree增加遍历的方法：
1、二叉树的递归遍历实现

• 前序遍历

    class BTree(object):
        ...
        def preorder(self, treenode):
            if not treenode:
                return None
            print(treenode.data)
            self.preorder(treenode.left)
            self.preorder(treenode.right)

• 中序遍历

    ...
    def inorder(self, treenode):
        if not treenode:
            return None
        self.inorder(treenode.left)
        print(treenode.data)
        self.inorder(treenode.right)

• 后序遍历

    ...
    def postorder(self):
        if not treenode:
            return None
        self.postorder(treenode.left)
        self.postorder(treenode.right)
        print(treenode.data)

2、二叉树的非递归遍历实现

• 前序遍历

class BTree(object):
    ...
    def preorder(self, treenode):
        S = []  # 栈
        if not treenode:
            return None
        while treenode:
            print(treenode.data)
            s.append(treenode)
            treenode = treenode.left
        if s:
            treenode = s.pop()
            treenode = treenode.right

• 中序遍历

    ...
    def inorder(self, treenode):
        s = []
        if not treenode:
            return None
        while treenode:
            s.append(treenode)
            treenode = treenode.left
        if s:
            treenode = s.pop()
            print(treenode.data)
            treenode = treenode.right

• 后序遍历

    ...
    def postorder(self, treenode):
        if not treenode:
            return None
        s = [] # 栈
        q = deque() # 队列
        q.append(treenode)
        while q:
            treenode = q.leftpop()
            if treenode.right:
                q.append(treenode.right)
            if treenode.left:
                q.append(treenode.left)
            s.append(treenode) # 将二叉树按NRL顺序压栈
        while s:
            print(s.pop().data) # 按LRN顺序出栈

层序遍历

若存在树BT如下，按层次顺序实现其遍历：

     1
   /   \
  2     3
 / \   / 
4   5 6   

结点输出顺序为123456。

    ...
    def levelorder(self, treenode):
        q = deque() # 队列
        q.append(treenode)
        while treenode:
            treenode = q.leftpop()
            print(q.leftpop().data)
            if treenode.right:
                q.append(treenode.left)
            if treenode.left:
                q.append(treenode.right)