Python 数据结构 -- 二叉树&二叉搜索树

"""
节点的度：子节点的个数
树的度：一棵树中，最大的节点的度就是树的度
叶节点：度为零的节点
兄弟节点：拥有相同父节点
层次：从根开始，根为第一层。。。
树的高度：最大层次
堂兄弟节点：父亲在同一层的节点
节点的祖先：从根到该节点所有的节点
"""

"""
二叉树的性质
性质一：在二叉树的第i层上至多有2^(i-1)个结点(i>0)
性质二：深度为k的二叉树至多有2^k-1个结点(k>0)
性质三：对于任意一棵二叉树，如果其叶结点数为N0，而度为2的结点总数为N2，则N0=N2+1
性质四：具有n个结点的完全二叉树的深度必为log2(n+1)
性质五：对完全二叉树，若从上至下、从左至右编号，则编号为i的结点，其左孩子编号为2i，右孩子编号为2i+1；其双亲的编号为i/2(i=1为根除外)
"""

"""
先序遍历：在先序遍历中，先访问根节点，然后递归使用先序遍历访问左子树，再递归使用先序遍历访问右子树
    根节点->左子树->右子树
中序遍历：在中序遍历中，递归使用中序遍历访问左子树，然后访问根节点，最后再递归使用中序遍历访问右子树
    左子树->根节点->右子树
后序遍历：在后序遍历中，先递归使用后序遍历访问左子树和右子树，最后访问根节点
    左子树->右子树->根节点 
"""

二叉树

#coding:utf-8


class Node(object):
    """构造结点"""
    def __init__(self, item):
        self.elem = item
        self.lchild = None
        self.rchild = None


class Tree(object):
    """二叉树"""
    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, 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)

    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=" ")




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(" ")

二叉搜索树
左节点小于父亲节点，右节点大于父亲节点

class Node(object):
    """构造结点"""
    def __init__(self, data):
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parent = None


class BST(object):
    """二叉搜索树"""
    def __init__(self, li=None):
        self.root = None
        if li:
            for val in li:
                self.insert_no_rec(val)

    def insert(self, node, val):
        #插入递归
        if not node:
            node = Node(val)
        elif val < node.data:
            node.lchild = self.insert(node.lchild, val)
            node.lchild.parent = node
        elif val > node.data:
            node.rchild = self.insert(node.rchild, val)
            node.rchild.parent = node
        return node

    def insert_no_rec(self, val):
        #插入非递归
        p = self.root
        if not p:               #空树
            self.root = Node(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:              #左孩子不存在
                    p.lchild = Node(val)
                    p.lchild.parent = p
                    return
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = Node(val)
                    p.rchild.parent = p
                    return
            else:
                return

    def query(self, node, val):
        #查找递归
        if not node:
            return None
        if node.data < val:
            return self.query(node.rchild, val)
        elif node.data > val:
            return self.query(node.lchild, val)
        else:
            return node

    def query_no_rec(self, val):
        #查找非递归
        p = self.root
        while p:
            if p.data < val:
                p = p.rchild
            elif p.data > val:
                p = p.lchild
            else:
                return p
        return None


    def pre_order(self, root):
        """先序遍历"""
        if root:
            print(root.data, end=" ")
            self.pre_order(root.lchild)
            self.pre_order(root.rchild)

    def in_order(self, root):
        """中序遍历"""
        if root:
            self.in_order(root.lchild)
            print(root.data, end=" ")
            self.in_order(root.rchild)

    def post_order(self, root):
        """后序遍历"""
        if root:
            self.post_order(root.lchild)
            self.post_order(root.rchild)
            print(root.data, end=" ")

    def __remove_node_1(self, node):
        #情况一：node是叶子节点
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  #node是它父亲的左孩子
            node.parent.lchild = None
        else:   #右孩子
            node.parent.rchild = None

    def __remove_node_21(self, node):
        #情况2.1：node只有一个左孩子
        if not node.parent: #根节点
            self.root = node.lchild
            node.lchild.parent = None
        elif node == node.parent.lchild:
            #node是parent的左孩子，且node只有一个左孩子
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:#node是parent的右孩子，但是node只有一个左孩子
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        #情况2.2：node只有一个右孩子
        if not node.parent:
            self.root = node.rchild
            node.rchild.parent = None
        elif node == node.parent.rchild:
            #node是parent的右孩子，并且node只有一个右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent
        else:#node是parent的左孩子，并且node只有一个右孩子
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:   #不是空树
            node = self.query_no_rec(val)
            if not node:    #不存在
                return False
            if not node.lchild and not node.rchild:#1.叶子节点
                self.__remove_node_1(node)
            elif not node.rchild:#2.1只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:#2.2只有一个右孩子
                self.__remove_node_22(node)
            else:
                #3.两个孩子都有
                min_node = node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                node.data = min_node.data
                #删除min_node
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)


tree = BST([4, 6, 7, 9, 2, 1, 3, 5, 8])
tree.in_order(tree.root)
tree.delete(4)
print("")
tree.delete(1)
print("")
tree.in_order(tree.root)