搜索二叉树 介绍 遍历 插入 查找 删除（三种情况）

class BiTreeNode:
	def __init__(self,data):
		self.data = data
		self.lchild = None
		self.rchild = None
		self.parent = None
	def __repr__(self):
		return self.data
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:
			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 1:
			if val <p.data:
				if p.lchild:#考虑左子树是否存在
					p = p.lchild
				else:			#左子树不存在
					p.lchild = BiTreeNode(val)
					p.lchild.parent=p
			elif val>p.data:
				if p.rchild:
					p = p.rchild
				else:			#右子树不存在
					p.rchild = BiTreeNode(val)
					p.rchild.parent=p
			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
		else:
			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):
		#情况1：node是叶子节点
		if not node.parent:
			self.root = None
		if node == node.parent.lchild:
			node.parent.lchild = None
		else:
			node.parent.rchild = None

def __remove_node_21(self,node):
		#情况2：node只有一个左孩子
		if not node.parent:
			self.root = node.lchild
			node.lchild.parent= None
		elif node ==node.parent.lchild:
			node.parent.lchild = node.lchild
			node.lchild.parent = node.parent
		else:
			node.parent.rchild = node.lchild
			node.lchild.parent = node.parent

def __remove_node_22(self,node):
		#情况2：node只有一个右孩子
		if not node.parent:#判断是否是根节点
			self.root = node.rchild
			node.rchild.parent= None
		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 :#不存在
				print('not there exist')
				return False
			if not (node.lchild and 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()
			else:#3.两个孩子都有
				min_node = node.rchild#右子树的最小节点保证比左子树打，比右子树小，能够成为新的根节点
				while min_node.lchild:
					min_node = min_node.lchild
				node.data = min_node.data
				#删除min_node 属于哪种情况1 还是 2.2
				if min_node .rchild:
					self.__remove_node_22(min_node)
				else:
					self.__remove_node_1(min_node)