算法六：树、二叉树(算法部分)

一、树的概念

树:

同前面的线性序列不一样，前面的线性序列都是一维的；但树是二维或多维的

树的节点，即列表中元素。

 

二、二叉树的概念 

二叉树:

是一种特殊的树,每个节点最多只能有0,1,2个子节点

二叉树(binary)是一种特殊的树。二叉树的每个节点最多只能有2个子节点：

四种二叉树

• 完全二叉树
• 满二叉树
• 平衡二叉树
• 排序二叉树，二叉查找树，，二叉搜索树

 

完全二叉树：

 

满二叉树：

平衡二叉树：左右两个子树的高度差的不超过1，，并且左右两个子树都是一棵平衡二叉树。

 

排序二叉树：又称为，二叉查找树，也称为二叉搜索树。

如果我们给二叉树加一个额外的条件，每个节点都不小于它左子树的任意节点，且都不大于它右子树的任意节点,得到一种被称作二叉搜索树(binary search tree)的特殊二叉树
二叉搜索树可以方便的实现搜索算法。在搜索元素x的时候，我们可以将x和根节点比较:

1. 如果x等于根节点，那么找到x，停止搜索 (终止条件)
2. 如果x小于根节点，那么搜索左子树
3. 如果x大于根节点，那么搜索右子树

 

 

树的存储：

树，一般不使用顺序表存储，而使用链式的存储。

 

二叉树的性质： 

 

三、树的实现

 

 

先序遍历：

中序遍历：

 

后序遍历：

 

class Node:
    """二叉树的节点"""
    def __init__(self, item):
        self.elem = item
        self.lchild = None
        self.rchild = None

class Tree:
    """二叉树"""
    def __init__(self):
        self.root = None

    def add(self, item):
        """添加：按广度优先(层次优先)的方式添加（类似队列），以完全二叉树为例添加"""
        node = Node(item)
        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 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)

    def preorder(self, node):
        """先顺遍历：根、左、右"""
        if node is None:
            return
        print("先顺遍历...", node.elem)
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    def inorder(self, node):
        """中顺遍历：左、根、右"""
        if node is None:
            return
        self.inorder(node.lchild)
        print("中顺遍历...", node.elem)
        self.inorder(node.rchild)

    def postorder(self, node):
        """后顺遍历：左、右、根"""
        if node is None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print("后顺遍历...", node.elem)


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)
    print("=============")
    tree.breadth_travel()
    print("=============")
    tree.preorder(tree.root)
    print("=============")
    tree.inorder(tree.root)
    print("=============")
    tree.postorder(tree.root)

 

 可以根据中序和先序，或中序和后序画出唯一的一棵树，但根据先序和后序，不能画出唯一的一棵树。