Python语言利用递归实现二叉排序树的查找，插入以及删除操作

最新推荐文章于 2024-07-30 17:23:09 发布

笨笨的蛋

最新推荐文章于 2024-07-30 17:23:09 发布

阅读量1.1k

点赞数

分类专栏：数据结构文章标签：数据结构 python 算法

本文链接：https://blog.csdn.net/qq_39463274/article/details/104700206

版权

数据结构专栏收录该内容

4 篇文章 1 订阅

订阅专栏

转载请说明

第一步：先建立一个Node节点类

class Node(object):
	def __init__(self, key=None):
		self.key = int(key)
		self.lchild = None
		self.rchild = None

第二步：初始化一个树

class BinTree(object):
	def __init__(self):
		self.root = None

第三步：在树类中实现递归查找树的方法

不论是否找到，都会返回待查找节点的双亲节点，根节点返回自己

	def search(self, data, bt=None, btf=None):
		" 递归查找:有返回就父亲节点,没有返回False"
		if bt == None:   # 子节点为空， 则表示没找到,返回父亲节点
			return None, btf
		elif bt.key == data: # 如果找到了返回其自己和父亲节点, root返回自身
			return bt, btf   
		elif bt.key > data:
			return self.search(data, bt.lchild, bt)
		else:
			return self.search(data, bt.rchild, bt)

第四步：插入节点

用查找方法找到双亲节点，然后直接判断大小插入

	def insert(self, data):
		if self.root == None:
			self.root = Node(data)      # 如果根节点为空， 则初始化根节点
		else: 
			result, node_parent = self.search(data, bt=self.root)  
			if result:
				return True  #如果已经有了则必须返回，不然再插入一次就会消灭掉原本位于该节点.子节点的.节点
			elif node_parent.key > data:
				node_parent.lchild = Node(data)
			else:
				node_parent.rchild = Node(data)

第五步：递归实现删除节点

	def deleteBSTree(self, data, bt=None):
		if bt == None:           #没找到那个节点，删除失败
			return bt        
		elif bt.key == data:                   #找到了
			if bt.lchild == None:   #如果左子树为空, 把bt右子树接给bt父亲节点
				bt = bt.rchild
			elif bt.rchild == None:  #如果右子树为空, 把bt左子树接给bt父亲节点
				bt = bt.lchild
			else:
				val = FindMax(bt.lchild)
				bt.key = val.key
				bt.lchild = deleteBSTree(val.key, bt.lchild)
		else:
			if bt.key > data:
				bt.lchild = self.deleteBSTree(data, bt.lchild)
			else:
				bt.rchild = self.deleteBSTree(data, bt.rchild)
		return bt

	def FindMax(self, bt):
		"""寻找直接前驱"""
		if bt:
			while bt.rchild:
				bt.rchild
		return bt

最后是测试代码和结果

	#中序遍历
	def inOrderTravel(self, bt):
		if bt is not None:
			self.inOrderTravel(bt.lchild)
			print(bt.key, end=" ")
			self.inOrderTravel(bt.rchild)
	def printTravel(self):
		print("中序遍历: ", end="")
		self.inOrderTravel(bt=self.root)
		print("\n")
if __name__ == '__main__':
	data_list = [70, 105, 115, 104, 99, 111, 109, 120]
	btree = BinTree()                       #初始化一个二叉排序树
	delete_node = 199

	for i in data_list:                     # 顺序插入
		btree.insert(i)						 #每次从根节点开始查找插入
	btree.printTravel()     #从·根节点遍历树， 中序遍历为有序列表！！！

	bt = btree.deleteBSTree(delete_node, btree.root)     #删除105
	print("删除{}, 再次中序遍历\n".format(delete_node))
	btree.printTravel()     #再次排序

在这里插入图片描述

最后是所有代码：

class Node(object):
	def __init__(self, key=None):
		self.key = int(key)
		self.lchild = None
		self.rchild = None

class BinTree(object):
	def __init__(self):
		self.root = None         # "***首先初始化根节点***"

	def insert(self, data):
		if self.root == None:
			self.root = Node(data)      # 如果根节点为空， 则初始化根节点
		else: 
			result, node_parent = self.search(data, bt=self.root)  
			if result:
				return True  #如果已经有了则必须返回，不然再插入一次就会消灭掉原本位于该节点.子节点的.节点
			elif node_parent.key > data:
				node_parent.lchild = Node(data)
			else:
				node_parent.rchild = Node(data)
	def search(self, data, bt=None, btf=None):
		" 递归查找:有返回就父亲节点,没有返回False"
		if bt == None:   # 子节点为空， 则表示没找到,返回父亲节点
			return None, btf
		elif bt.key == data: # 如果找到了返回其自己和父亲节点, root返回自身
			return bt, btf   
		elif bt.key > data:
			return self.search(data, bt.lchild, bt)
		else:
			return self.search(data, bt.rchild, bt)

	def deleteBSTree(self, data, bt=None):
		if bt == None:           #没找到那个节点，删除失败
			return bt        
		elif bt.key == data:                   #找到了
			if bt.lchild == None:   #如果左子树为空, 把bt右子树接给bt父亲节点
				bt = bt.rchild
			elif bt.rchild == None:  #如果右子树为空, 把bt左子树接给bt父亲节点
				bt = bt.lchild
			else:
				val = FindMax(bt.lchild)
				bt.key = val.key
				bt.lchild = deleteBSTree(val.key, bt.lchild)
		else:
			if bt.key > data:
				bt.lchild = self.deleteBSTree(data, bt.lchild)
			else:
				bt.rchild = self.deleteBSTree(data, bt.rchild)
		return bt
	
	def FindMax(self, bt):
		"""寻找直接前驱"""
		if bt:
			while bt.rchild:
				bt.rchild
		return bt
	
	#中序遍历
	def inOrderTravel(self, bt):
		if bt is not None:
			self.inOrderTravel(bt.lchild)
			print(bt.key, end=" ")
			self.inOrderTravel(bt.rchild)
	
	def printTravel(self):
		print("中序遍历: ", end="")
		self.inOrderTravel(bt=self.root)
		print("\n")
	
if __name__ == '__main__':
	data_list = [70, 105, 115, 104, 99, 111, 109, 120]
	btree = BinTree()                       #初始化一个二叉排序树
	delete_node = 199

	for i in data_list:                     # 顺序插入
		btree.insert(i)						 #每次从根节点开始查找插入
	btree.printTravel()     #从·根节点遍历树， 中序遍历为有序列表！！！

	bt = btree.deleteBSTree(delete_node, btree.root)     #删除105
	print("删除{}, 再次中序遍历\n".format(delete_node))
	btree.printTravel()     #再次排序