一、树

1. 定义：是一种结构数据，由n(n>=1)个有限节点组成一个具有层次关系的集合
2. 特性：

• 每个节点有领个或多个子节点
• 没有父节点的节点称为根节点
• 每一个非根节点有且只有一个父节点
• 除根节点外，每个子节点可以分为多个不想交的子数

3. 术语：
   结点的度：结点拥有的子树的数目。
   叶子：度为零的结点。
   分支结点：度不为零的结点。
   树的度：树中结点的最大的度。
   层次：根结点的层次为1，其余结点的层次等于该结点的双亲结点的层次加1。
   树的高度：树中结点的最大层次。
   无序树：如果树中结点的各子树之间的次序是不重要的，可以交换位置。
   有序树：如果树中结点的各子树之间的次序是重要的, 不可以交换位置。
   森林：0个或多个不相交的树组成。对森林加上一个根，森林即成为树；删去根，树即成为森林。

二、二叉树

1. 特性：

• 性质1：二叉树第i层上的结点数目最多为 2{i-1} (i≥1)。
• 性质2：深度为k的二叉树至多有2{k}-1个结点(k≥1)。
• 性质3：包含n个结点的二叉树的高度至少为log2 (n+1)。
• 性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1。
  1.1 性质1：二叉树第i层上的结点数目最多为 2{i-1} (i≥1)

证明：下面用"数学归纳法"进行证明。
(01) 当i=1时，第i层的节点数目为2{i-1}=2{0}=1。因为第1层上只有一个根结点，所以命题成立。
(02) 假设当i>1，第i层的节点数目为2{i-1}。这个是根据(01)推断出来的！
下面根据这个假设，推断出"第(i+1)层的节点数目为2{i}"即可。
由于二叉树的每个结点至多有两个孩子，故"第(i+1)层上的结点数目" 最多是 "第i层的结点数目的2倍"。即，第(i+1)层上的结点数目最大值=2×2{i-1}=2{i}。
故假设成立，原命题得证！

2.2 性质2：深度为k的二叉树至多有2{k}-1个结点(k≥1)

证明：在具有相同深度的二叉树中，当每一层都含有最大结点数时，其树中结点数最多。利用"性质1"可知，深度为k的二叉树的结点数至多为：
20+21+…+2k-1=2k-1
故原命题得证！

2.3 性质3：包含n个结点的二叉树的高度至少为log2 (n+1)

证明：根据"性质2"可知，高度为h的二叉树最多有2{h}–1个结点。反之，对于包含n个节点的二叉树的高度至少为log2(n+1)。

2.4 性质4：在任意一棵二叉树中，若终端结点的个数为n0，度为2的结点数为n2，则n0=n2+1

证明：因为二叉树中所有结点的度数均不大于2，所以结点总数(记为n)="0度结点数(n0)" + "1度结点数(n1)" + "2度结点数(n2)"。由此，得到等式一。
(等式一) n=n0+n1+n2
　 另一方面，0度结点没有孩子，1度结点有一个孩子，2度结点有两个孩子，故二叉树中孩子结点总数是：n1+2n2。此外，只有根不是任何结点的孩子。故二叉树中的结点总数又可表示为等式二。
(等式二) n=n1+2n2+1
由(等式一)和(等式二)计算得到：n0=n2+1。原命题得证！

2. 代码实现

class Node(object):
    ## 
    # 节点类
    # 初始化节点
    # # 
    def __init__(self, element, lchild=None, rchild=None):
        self.element = element
        self.lchild = lchild
        self.rchild = rchild


class Tree(object):
    ##
    # 树类
    # 初始化节点
    # #
    def __init__(self, root=None):
        self.root = root
    # 添加节点

    def add(self, item):
        node = Node(item)
        if self.root is None:
            self.root = node
            return
        else:
            queue = []
            queue.append(self.root)
            while queue:
                cur_node = queue.pop(0)
                if cur_node.lchild is None:
                    cur_node.lchild = node
                    return
                elif cur_node.rchild is None:
                    cur_node.rchild = node
                    return
                else:
                    queue.append(cur_node.lchild)
                    queue.append(cur_node.rchild)

    # 广度优先

    def width_circle(self):
        if self.root is None:
            return ' '
        else:
            queue = []
            queue.append(self.root)
            while queue:
                cur_node = queue.pop()
                print(cur_node.element, end=' ')
                if cur_node.rchild 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 == None:
            return
        print(node.element, end=' ')
        self.preorder(node.lchild)
        self.preorder(node.rchild)

    # 中序遍历

    def inorder(self, node):
        if node == None:
            return
        self.inorder(node.lchild)
        print(node.element, end=' ')
        self.preorder(node.rchild)

    # 后序遍历

    def postorder(self, node):
        if node == None:
            return
        self.postorder(node.lchild)
        self.postorder(node.rchild)
        print(node.element, end=' ')


if __name__ == '__main__':
    t = Tree()
    t.add(0)
    t.add(1)
    t.add(2)
    t.add(3)
    t.add(4)
    t.add(5)
    t.add(6)
    t.add(7)
    t.add(8)
    t.add(9)
    print("\n广度优先BFS")
    t.width_circle()
    print("\n前序遍历")
    t.preorder(t.root)
    print("\n中序遍历")
    t.inorder(t.root)
    print("\n后序遍历")
    t.postorder(t.root)

3. 满二叉树
   定义：高度为h，并且由2{h} –1个结点的二叉树，被称为满二叉树

   
   
   满二叉树.jpg
4. 完全二叉树
   定义：一棵二叉树中，只有最下面两层结点的度可以小于2，并且最下一层的叶结点集中在靠左的若干位置上。这样的二叉树称为完全二叉树。
   特性：叶子结点只能出现在最下层和次下层，且最下层的叶子结点集中在树的左部。显然，一棵满二叉树必定是一棵完全二叉树，而完全二叉树未必是满二叉树。
   
   完全二叉树.jpg

三、二叉查找树(Binary Search Tree)

定义：二叉查找树(Binary Search Tree)，又被称为二叉搜索树。设x为二叉查找树中的一个结点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个结点，则key[y] <= key[x]；如果y是x的右子树的一个结点，则key[y] >= key[x]。

二叉查找树.jpg

• (01) 若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• (02) 任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• (03) 任意节点的左、右子树也分别为二叉查找树。
• (04) 没有键值相等的节点（no duplicate nodes）。

1. 查找与插入

当二叉查找树不为空时： 首先将给定值与根结点的关键字比较，若相等，则查找成功 若小于根结点的关键字值，递归查左子树 若大于根结点的关键字值，递归查右子树 若子树为空，查找不成功 二叉排序树是一种动态树表。其特点是：树的结构通常不是一次生成的，而是在查找过程中，当树中不存在关键字等于给定值的结点时再进行插入。新插入的结点一定是一个新添加的叶子结点，并且是查找不成功时查找路径上访问的最后一个结点的左孩子或右孩子结点。如下图所示:

二叉搜索树查找与插入.png

2. 删除

二叉查找树的删除操作分为三种情况： 如果待删除的节点是叶子节点，那么可以立即被删除，如下图所示：

二叉树删除叶子节点

如果节点只有一个儿子，则将此节点parent的指针指向此节点的儿子，然后删除节点，如下图所示：

二叉搜索树删除单子节点

如果节点有两个儿子，则将其右子树的最小数据代替此节点的数据，并将其右子树的最小数据删除，如下图所示:

二叉搜索树删除双子节点

4. 代码实现

class Node:
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
 
class BST:
    def __init__(self, node_list):
        self.root = Node(node_list[0])
        for data in node_list[1:]:
            self.insert(data)
 
    # 搜索
    def search(self, node, parent, data):
        if node is None:
            return False, node, parent
        if node.data == data:
            return True, node, parent
        if node.data > data:
            return self.search(node.lchild, node, data)
        else:
            return self.search(node.rchild, node, data)
 
    # 插入
    def insert(self, data):
        flag, n, p = self.search(self.root, self.root, data)
        if not flag:
            new_node = Node(data)
            if data > p.data:
                p.rchild = new_node
            else:
                p.lchild = new_node
 
    # 删除
    def delete(self, root, data):
        flag, n, p = self.search(root, root, data)
        if flag is False:
            print "无该关键字，删除失败"
        else:
            if n.lchild is None:
                if n == p.lchild:
                    p.lchild = n.rchild
                else:
                    p.rchild = n.rchild
                del p
            elif n.rchild is None:
                if n == p.lchild:
                    p.lchild = n.lchild
                else:
                    p.rchild = n.lchild
                del p
            else:  # 左右子树均不为空
                pre = n.rchild
                if pre.lchild is None:
                    n.data = pre.data
                    n.rchild = pre.rchild
                    del pre
                else:
                    next = pre.lchild
                    while next.lchild is not None:
                        pre = next
                        next = next.lchild
                    n.data = next.data
                    pre.lchild = next.rchild
                    del p
 
 
    # 先序遍历
    def preOrderTraverse(self, node):
        if node is not None:
            print node.data,
            self.preOrderTraverse(node.lchild)
            self.preOrderTraverse(node.rchild)
 
    # 中序遍历
    def inOrderTraverse(self, node):
        if node is not None:
            self.inOrderTraverse(node.lchild)
            print node.data,
            self.inOrderTraverse(node.rchild)
 
    # 后序遍历
    def postOrderTraverse(self, node):
        if node is not None:
            self.postOrderTraverse(node.lchild)
            self.postOrderTraverse(node.rchild)
            print node.data,
 
a = [49, 38, 65, 97, 60, 76, 13, 27, 5, 1]
bst = BST(a)  # 创建二叉查找树
bst.inOrderTraverse(bst.root)  # 中序遍历
 
bst.delete(bst.root, 49)
print
bst.inOrderTraverse(bst.root)