数据结构之二叉树

一、定义

二叉树，指的是至多包含两个子结点的树结构。

二、区别

数组：查找的复杂度为O(1)，插入和删除由于需要移位操作，因此复杂度为O(N)；
链表：插入和删除操作只需要更换一个结点，因此其复杂度为O(1)，而遍历则需要O(N)的复杂度；
二叉树：以树的结构来存储数据，插入、删除和查找操作的复杂度均为O($lo{g}_2^N$)。

三、存储

顺序存储：空缺位置用#号替代，适合稠密存储。当二叉树接近满二叉树时效率较高。
链式存储：最常用的存储方式。

四、遍历

先序遍历（preOrder） ：先遍历根结点，再遍历左孩子结点，最后再遍历右孩子结点→[1, 2, 5, 6, 4]
中序遍历（inOrder） ：先遍历左孩子结点，再遍历根结点，最后再遍历右孩子结点→[5, 2, 6, 1, 4]
先序遍历（postOrder）：先遍历左孩子结点，再遍历右孩子结点，最后再遍历根结点→[5, 6, 2, 4, 1]
层次遍历（levelOrder）：从上往下，从左到右依次遍历→[1, 2, 4, 5, 6]

五、性质

1. 给定一个二叉树的，可以得到唯一的先序、中序和后序遍历序列；
2. 给定一个二叉树其中的一个遍历序列，无法确定一颗二叉树；
3. 由二叉树的先序序列和中序序列、中序序列和后序序列以及层序序列和中序序列可以唯一的确定一棵二叉树；但只给出先序序列和后序序列则无法确定唯一的一棵二叉树；

六、实现

class Node(object):
    def __init__(self, x=None):
        self.value, self.left, self.right = x, None, None


class BinaryTree(object):
    def __init__(self):
        self.root = Node()
        self.queue = []

    def insert_node(self, x):
        # 插入一个结点

        node = Node(x)  # 创建新结点

        if self.root.value:
            # 若根结点不为空，则输出当前的根结点
            temp = self.queue[0]

            if not temp.left:
                # 如果左子树为空，则将当前结点添加到左子树
                temp.left = node
                self.queue.append(temp.left)
            else:
                # 否则添加到右子树
                temp.right = node
                self.queue.append(temp.right)
                # 如果当前右子树不为空，则弹出根结点，以便后续结点的添加
                self.queue.pop(0)
        else:
            # 若根结点为空，则将当前结点添加到根结点上
            self.root = node
            self.queue.append(self.root)

    def preorder(self, root, res):
        # 先序遍历
        if root:
            res.append(root.value)
            self.preorder(root.left, res)
            self.preorder(root.right, res)
        return res

    def inorder(self, root, res):
        # 中序遍历
        if root:
            self.inorder(root.left, res)
            res.append(root.value)
            self.inorder(root.right, res)
        return res

    def postorder(self, root, res):
        # 后续遍历
        if root:
            self.postorder(root.left, res)
            self.postorder(root.right, res)
            res.append(root.value)
        return res

    @staticmethod
    def levelorder(root, res):
        # 层次遍历
        queue = [root]
        while queue:
            curnode = queue.pop(0)
            res.append(curnode.value)
            if curnode.left:
                queue.append(curnode.left)
            if curnode.right:
                queue.append(curnode.right)
        return res


def main():
    tree = BinaryTree()
    for i in range(7):
        tree.insert_node(i+1)

    preorder = tree.preorder(tree.root, [])
    print("先序遍历序列为：", preorder)

    inorder = tree.inorder(tree.root, [])
    print("中序遍历序列为：", inorder)

    postorder = tree.postorder(tree.root, [])
    print("后序遍历为：{}".format(postorder))

    levelorder = tree.levelorder(tree.root, [])
    print("层次遍历为：{}".format(levelorder))


if __name__ == '__main__':
    main()