数据结构与算法笔记（十四）—— 二叉树

一、二叉树的基本概念

二叉树是每个节点最多有两个子树的树结构。通常子树被称作“左子树”（left subtree） 和“右子树”（right subtree）。

---

二、二叉树的性质(特性)

性质 1: 在二叉树的第 i 层上至多有 2^(i-1)个节点（i>0）

性质 2: 深度为 k 的二叉树至多有 2^k - 1 个节点（k>0）

性质 3: 对于任意一棵二叉树，如果其叶节点数为 N0，而度数为 2 的结点总数为 N2， 则 N0=N2+1;

性质 4:具有 n 个节点的完全二叉树的深度必为 log2(n+1) (以2为底)

性质 5:对完全二叉树，若从上至下、从左至右编号，则编号为 i 的结点，其左孩子编 号必为 2i，其右孩子编号必为 2i＋1；其双亲的编号必为 i/2（i＝1 时为根，除外）

---

三、二叉树的节点及树的创建

3.1、节点的创建

class Node(object): 
    """节点类""" 
    def __init__(self, elem=-1, lchild=None, rchild=None): 
        self.elem = elem 
        self.lchild = lchild 
        self.rchild = rchild

---

3.2、树的创建

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

    def add(self,elem):
        '''为树添加结点'''
        node = Node(elem)
        if self.root is None:
            self.root = node
            return

        queue = [self.root]

        while queue:
            # 弹出队列的第一个元素
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)

            if cur_node.rchild is None:
                cur_node.rchild = None
                return
            else:
                queue.append(cur_node.rchild)

---

四、二叉树遍历

树的遍历是树的一种重要的运算。所谓遍历是指对树中所有结点的信息的访问，即依次 对树中每个结点访问一次且仅访问一次，我们把这种对所有节点的访问称为遍历（traversal）。 那么树的两种重要的遍历模式是深度优先遍历和广度优先遍历，深度优先一般用递归，广度优先一般用队列。一般情况下能用递归实现的算法大部分也能用堆栈来实现。

4.1、广度优先遍历(层次遍历)

从树的 root 开始，从上到下从从左到右遍历整个树的节点。

代码：

def breadth_travel(self):
    """利用队列实现树的层次遍历"""
    if self.root is None:
        return
    queue = [self.root]
    while queue:
        cur_node = queue.pop(0)
        print(cur_node.elem)
        if cur_node.lchild is not None:
            queue.append(cur_node.lchild)
        if cur_node.rchild is not None:
            queue.append(cur_node.rchild)

---

4.2、深度优先遍历

对于一颗二叉树，深度优先搜索(Depth First Search)是沿着树的深度遍历树的节点，尽可能深的搜索树的分支。

那么深度遍历有重要的三种方法。这三种方式常被用于访问树的节点，它们之间的不同 在于访问每个节点的次序不同。这三种遍历分别叫做先序遍历（preorder），中序遍历（inorder） 和后序遍历（postorder）。我们来给出它们的详细定义，然后举例看看它们的应用。

补充小知识：
在已知中序遍历和先序遍历（或者中序遍历和后序遍历）结果时，我们可以推导出树的结构（注意必须知道中序遍历结果，否则是没法推导的）

---

4.2.1、先序遍历

在先序遍历中，我们先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树。

根节点 --> 左子树 --> 右子树

代码：

def preorder(self,node):
    '''先序遍历'''
    if node is None:
        return
    print(node.elem, end=' ')
    self.preorder(node.lchild)
    self.preorder(node.rchild)

---

4.2.2、中序遍历

在中序遍历中，我们递归使用中序遍历访问左子树，然后访问根节点，最后再递 归使用中序遍历访问右子树。

左子树 -->根节点 --> 右子树

代码：

def inorder(self,node):
    '''中序遍历'''
    if node is None:
        return
    self.inorder(node.lchild)
    print(node.elem, end=' ')
    self.inorder(node.rchild)

---

4.2.3、后序遍历

在后序遍历中，我们先递归使用后序遍历访问左子树和右子树，最后访问根节点。

左子树 --> 右子树 --> 根节点

代码：

def postorder(self,node):
    '''后序遍历'''
    if node is None:
        return
    self.postorder(node.lchild)
    self.postorder(node.rchild)
    print(node.elem, end=' ')

---

4.3、完整代码遍历测试

class Node(object):
    """节点类"""
    def __init__(self, elem):
        self.elem = elem
        self.lchild = None
        self.rchild = None

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

    def add(self,elem):
        '''为树添加结点'''
        node = Node(elem)
        if self.root is None:
            self.root = node
            return

        queue = [self.root]

        while queue:
            # 弹出队列的第一个元素
            cur_node = queue.pop(0)
            if cur_node.lchild is None:
                cur_node.lchild = node
                return
            else:
                queue.append(cur_node.lchild)

            if cur_node.rchild is None:
                cur_node.rchild = node
                return
            else:
                queue.append(cur_node.rchild)

    def preorder(self,node):
        '''先序遍历'''
        if node is None:
            return
        print(node.elem, end=' ')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self,node):
        '''中序遍历'''
        if node is None:
            return
        self.inorder(node.lchild)
        print(node.elem, end=' ')
        self.inorder(node.rchild)

    def postorder(self,node):
        '''后序遍历'''
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.elem, end=' ')


    def breadth_travel(self):
        """利用队列实现树的层次遍历"""
        if self.root is None:
            return
        queue = [self.root]
        while queue:
            cur_node = queue.pop(0)
            print(cur_node.elem,end=' ')
            if cur_node.lchild is not None:
                queue.append(cur_node.lchild)
            if cur_node.rchild is not None:
                queue.append(cur_node.rchild)


if __name__ == '__main__':
    tree = Tree()
    for i in range(10):
        tree.add(i)
    tree.breadth_travel()
    print('')
    tree.preorder(tree.root)
    print('')
    tree.inorder(tree.root)
    print('')
    tree.postorder(tree.root)

遍历结果：

层次：0 1 2 3 4 5 6 7 8 9 
先序：0 1 3 7 8 4 9 2 5 6
中序：7 3 8 1 9 4 0 5 2 6
后序：7 8 3 9 4 1 5 6 2 0