数据结构与算法全套精讲(python版) (六)树

1. 树的术语

2. 树的种类 

 

(1). 完全二叉树

(2). 满二叉树

 (3).  二叉排序树

 

 

3. 树的存储 

(1). 顺序存储(非主流) 

(2) . 链式存储

4 . 树的常见应用场景

5. 二叉树性质

 

6. 二叉树遍历

广度遍历(层次)：一层一层的走，每层从左至右；

深度遍历：先序遍历(根节点—>左子树—>右子树)，中序遍历(左子树—>根节点—>右子树)，后序遍历(左子树—>右子树—>根节点)。

例：

 

遍历实现：

class Node(object):
    def __init__(self,data):
        self.data = data
        self.lchild = None
        self.rchild = None

class Tree(object):
    def __init__(self):
        self.root = None

    def add(self,item):#插入节点
        node = Node(item)
        'bool([])==False, bool([None])==True'
        if self.root == None:#当根节点None，[self.root]即[None]
            self.root = node
            return
        queue = [self.root]#二叉树以list形式存储
        while queue:#从根开始，依次往下检查各节点，直至全取出
            cur = queue.pop(0)#每轮把list现有的首节点取出
            if not cur.lchild:
                cur.lchild = node
                return
            else:
                queue.append(cur.lchild)
            if not cur.rchild:
                cur.rchild = node
                return
            else:
                queue.append(cur.rchild)
    '广度遍历'
    def breadth_travel(self):#层次遍历
        'bool([])==False, bool([None])==True'
        if self.root == None:#当根节点None，[self.root]即[None]
            return
        queue = [self.root]#二叉树以list形式存储
        while queue:#从根开始，依次往下检查各节点，直至全取出
            cur = queue.pop(0)#每轮把list现有的首节点取出
            print(cur.data,end=' ')
            if  cur.lchild:
                queue.append(cur.lchild)
            if  cur.rchild:
                queue.append(cur.rchild)

    '深度遍历'
    def preorder(self,node):#前序遍历
        if not node:
            return
        print(node.data,end=' ')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):#中序遍历
        if not node:
            return
        self.inorder(node.lchild)
        print(node.data, end=' ')
        self.inorder(node.rchild)

    def postorder(self,node):#后序遍历
        if not node:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.data,end=' ')


if __name__ == '__main__':
    tree = Tree()
    tree.add(0)
    tree.add(1)
    tree.add(2)
    tree.add(3)
    tree.add(4)
    tree.add(5)
    tree.add(6)
    tree.add(7)
    tree.add(8)
    tree.add(9)
    tree.breadth_travel()
    print('')
    tree.preorder(tree.root)
    print('')
    tree.inorder(tree.root)
    print('')
    tree.postorder(tree.root)
    print('')

7.  由一直遍历反推出这棵树

在深度遍历里，已经两种遍历则可退出该树，且其中一种必须是中序遍历。

例1：已知先序遍历为0 1 3 7 8 4 9 2 5 6  ，中序遍历为7 3 8 1 9 4 0 5 2 6 ，请画出该二叉树

例2：已知后序遍历为7 8 3 9 4 1 5 6 2 0   ，中序遍历为7 3 8 1 9 4 0 5 2 6 ，请画出该二叉树