数据结构与算法之 数据结构： 二叉树、二叉搜索树

数据结构：数据元素的集合 + 数据元素之间的关系

二叉树：

1、特点：
    链式存储
2、4种遍历：

        先序遍历
        中序遍历
        后序遍历
        层次遍历

from collections import deque

class BiTreeNode:
    """二叉树"""
    def __init__(self, data):
        """节点"""
        self.data = data
        self.lchild = None
        self.rchild = None

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

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

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

def level_order(root):
    queue = deque
    queue.append(root)
    # 只要队不空，先出队一个元素，然后把它的左右孩子进队
    while len(queue) > 0:
        node = queue.popleft()
        print(node.data, end=',')
        if node.lchild:
            queue.append(node.lchild)
        if node.rchild:
            queue.append(node.rchild)
                

a = BiTreeNode("A")
b = BiTreeNode("B")
c = BiTreeNode("C")
d = BiTreeNode("D")
e = BiTreeNode("E")
f = BiTreeNode("F")
g = BiTreeNode("G")

e.lchild = a
e.rchild = g
a.rchild = c
c.lchild = b
c.rchild = d
g.rchild = f

root = e

pre_order(root)
print('')
in_order(root)
print('')
post_order(root)
print('')
level_order(root)

二叉搜索树

1.特点：
    左子树小于根节点，右子树大于根节点

2、时间复杂度：O(lgn)
    最坏情况下，二叉搜索树2肯非常偏斜，O(n)
 解决方法：
    随机化插入
    AVL树

3、4种遍历：

        先序遍历
        中序遍历
        后序遍历
        层次遍历

import random
class BiTreeNode:
    def __init__(self, data):
        """节点"""
        self.data = data
        self.lchild = None
        self.rchild = None
        self.parent = None

class BST:
    """二叉搜索树"""
    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 = BiTreeNode(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 = BiTreeNode(val)
            return
        while True:
            if val < p.data:
                if p.lchild:
                    p = p.lchild
                else:
                    p.lchild = BiTreeNode(val)
                    p.lchild.parent = p
                    return 
            elif val > p.data:
                if p.rchild:
                    p = p.rchild
                else:
                    p.rchild = BiTreeNode(val)
                    p.rchild.parent = p
                    return 
            else:
                return 


    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 query(self, node, val):
        """递归法查询"""
        if not node:
            return None
        elif 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 False    # 根节点不存在则返回Flase

    
    def __remove_node_1(self, node):
        """情况1：node是叶子节点，则直接删掉"""        
        if not node.parent:
            self.root = None
        if node == node.parent.lchild:  # node为它父亲的左孩子
            self.parent.lchild = None
        else:   # node为它父亲的右孩子
            self.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为它父亲的左孩子
            node.parent.lchild = node.lchild
            node.lchild.parent = node.parent
        else:   # 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.lchild:  # node为它父亲的左孩子
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:   # node为它父亲的右孩子
            node.parent.rchild = node.rchild
            node.rchild.parent = node.parent

    def delete(self, val):
        if self.root:   # 不是空树
            node = self.query_no_rec(val)
            if node:    # 如果不存在，则报错
                return False
            if not node.lchild and not node.rchild: # 情况1：node是叶子节点，则直接删掉
                self.__remove_node_1(node)
            elif not node.rchild:   # 情况2.1：node只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild:   # 情况2.2：node只有一个右孩子
                self.__remove_node_22(node)
            else:   # 情况3：node的左右孩子都有
                # 先找到node的右子树上的最小结点min_node
                min_node =  node.rchild
                while min_node.lchild:
                    min_node = min_node.lchild
                # node的右子树上的最小结点min_node，将它替换掉node
                node.data = min_node.data
                # 删除min_node结点（肯定没有左孩子）时，需要判断它是否有右孩子
                if min_node.rchild:
                    self.__remove_node_22(min_node)
                else:
                    self.__remove_node_1(min_node)
    

li = list(range(0, 10))
random.shuffle(li)

tree = BST(li)
tree.pre_order(tree.root)
print("")
tree.in_order(tree.root)
print("")
tree.post_order(tree.root)
"""
1,0,6,3,2,4,5,8,7,9,
0,1,2,3,4,5,6,7,8,9,
0,2,5,4,3,7,9,8,6,1,
"""