数据结构－二叉树

from collections import deque


class BitTreeNode:
    def __init__(self,data):
        self.data=data
        self.lchild = None #左孩子
        self.rchild = None #右孩子


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

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


root = e  #根节点
# print(root.lchild.rchild.data)

#前序遍历
def pre_order(root):
    if root :     #——访问根结点的操作发生在遍历其左右子树之前。
        print(root.data,end=‘,‘)
        pre_order(root.lchild)
        pre_order(root.rchild)

# pre_order(root)


# 中序遍历
def in_order(root):
    if root :
        in_order(root.lchild)   #root左孩子
        print(root.data,end=‘,‘)#root本身
        in_order(root.rchild)   #root右孩子

# in_order(root)

# 后序遍历

def post_order(root):
    if root:
        post_order(root.lchild)
        post_order(root.rchild)
        print(root.data,end=‘,‘)

# post_order(root)

#层序遍历
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)


level_order(root)

‘‘‘插入数据到树‘‘‘
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)   #不存在创建树和赋值node
        elif val<node.data:    # 查找的数val小于选择的树node
            node.lchild = self.insert(node.lchlid,val)#左子树插入val
            node.lchild.parent = node   #链接为node子树

        elif val>node.data :
            node.rchild = self.insert(node.lchlid,val)
            node.rchild.paret = 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 query(self,node,val):
        if not node:
            return None
        if node.data<val:
            return self.query(node.rchile,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)  # root左孩子
            print(root.data, end=‘,‘)  # root本身
            self.in_order(root.rchild)  # root右孩子


    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    #将node父亲的左孩子也就是node滞空
        else:
            node.parent.rchild = None

    def __remove_node_21(self, node):
        #情况2.1:node只有一个左孩子
        if not node.parent:             #node没有父亲也就是根节点
            self.root = node.lchild     #node被删除node的左儿子上位
            node.lchild.parent = None   #原node位置滞空
        elif node == node.parent.lchild :
            node.parent.lchild = node.lchild   #node父亲的左孩子＝node的左孩子
            node.lchild.parent = node.parent
        else:
            node.parent.rchild = node.lchild
            node.lchild.parent = node.parent

    def __remove_node_22(self, node):
        #情况2.1:node只有一个右孩子
        if not node.parent:
             self.root = node.rchild
        elif node == node.parent.lchild :
            node.parent.lchild = node.rchild
            node.rchild.parent = node.parent
        else:
            node.parent.rchild = 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 : #叶子节点
                self.__remove_node_1(node)
            elif not node.rchild :                  #只有一个左孩子
                self.__remove_node_21(node)
            elif not node.lchild :                  #只有一个右孩子
                self.__remove_node_22(node)
            else:                                   #两个孩子都有
                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([2,3,4,1,6,7,9,5,8]) #建树
# tree.post_order(tree.root)
# print(‘‘)
tree.in_order(tree.root)
print(‘‘)
# tree.post_order(tree.root)


# print(tree.query_no_rec(3).data)  #查找

tree.delete(4)
tree.in_order(tree.root)