**定义:**查找树是一种数据结构,它支持多种动态集合操作,如查找、插入、删除等,既可以用作字典,也可以用作优先队列。
二叉树的遍历:
二叉树的遍历分为前序遍历、中序遍历和后序遍历,可以采用递归的方法遍历,遍历一棵含n个节点的二叉树时间复杂度为O(n)。
中序遍历:先遍历左子树,然后遍历根节点,最后遍历右子树。
先序遍历:先遍历根节点,然后左子树,最后右子树。
后序遍历:先遍历左子树,然后右子树,最后根节点。
二叉树查找:
先从根节点开始,查找值大于节点值,则往右子树查找,小于则往左子树查找,直到找到值与查找值相等的节点,或者查询子树为空。算法时间复杂度为O(h),h为树的深度。
最大值与最小值:
最大值:从根节点开始,一直遍历右子树,直到右子树为空,返回最后的节点值即为最大值。
最小值:从根节点开始,一直遍历左子树,直到左子树为空,返回最后的节点值即为最小值。
时间复杂度为O(h)。
后继: 节点x的后继为中序遍历顺序的下一个结点,如果节点的值均不相同,则后继为大于该节点的值里最小值得那个节点。如果x右子树非空,则后继为右子树最左边的节点,通过查找右子树最小值可得。如果右子树为空,如果存在后继y,则y为x最低祖先节点,且y的左儿子也是x的祖先,为了找到y,沿着x往上查找,直到某节点是其父节点的左儿子为止。时间复杂度为O(h)。
插入节点: 先按搜索的顺序向下遍历,直到最后插入合适的位置,新插入的节点没有儿子节点。时间复杂度为O(h)。
删除节点: 删除节点取决于被删除的节点是否有儿子节点,分三种情况:
1,没有儿子节点,直接删除即可。
2,有一个儿子,将该节点删除,同时将其父节点和儿子节点连接上。
3,有左右儿子,则删除其后继,并用后继的值和附加数据替换该节点的值和附加数据。
时间复杂度:O(h)。
随机构造的二叉查找树深度为O(log(n))。
python代码:
# -*- coding: utf-8 -*-
"""
Created on Mon May 11 11:12:32 2020
@author: oym
"""
class Binarytree:
def __init__(self,value=None,left=None,right=None,parent=None): #初始化
self.value=value
self.left=left
self.right=right
self.parent=None
if left!=None:
self.left.parent=self
if right!= None:
self.right.parent=self
def preTraverse(self): #前序遍历
if self!=None:
print(self.value, end= ' ')
if self.left!=None:
self.left.preTraverse()
if self.right!=None:
self.right.preTraverse()
else:
return
def midTraverse(self): #中序遍历
if self!=None:
if self.left!=None:
self.left.midTraverse()
print(self.value, end=' ')
if self.right!=None:
self.right.midTraverse()
else:
return
def lastTraverse(self): #后序遍历
if self!=None:
if self.left!=None:
self.left.lastTraverse()
if self.right!=None:
self.right.lastTraverse()
print(self.value, end=' ')
else:
return
def search(self,value): #查找
if self.value == value:
return self
elif (value<self.value and self.left!=None):
return self.left.search(value)
elif value>self.value and self.right!=None:
return self.right.search(value)
else:
return
def get_minimun(self): #取最小值
if self.left==None:
return self
else:
return self.left.get_minimun()
def get_maximun(self): #取最大值
if self.right==None:
return self
else:
return self.right.get_maximun()
def find_successor(self): #寻找节点的后继
if self.right:
return self.right.get_minimun()
else:
p=self.parent
x=self
while p and p.right==x:
x=p
p=p.parent
return p
def findvalue_successor(self,value): #寻找值得后继
node = self.search(value)
return node.find_successor()
def insert_value(self,value): #插入新值
if self.value>value:
if self.left:
self.left.insert_value(value)
else:
new_node = Binarytree(value,parent=self)
self.left=new_node
else:
if self.right:
self.right.insert_value(value)
else:
new_node = Binarytree(value,parent=self)
self.right=new_node
def delete_value(self,value): #删除值
node=self.search(value)
self.delete_node(node)
def delete_node(self,node): #删除节点
if node==None:
return
else:
if node.left==None and node.right==None:
if node.parent!=None:
if node.parent.left==node:
node.parent.left=None
else:
node.parent.right=None
else:
node=None
elif node.left!=None and node.right!=None:
replace_node=self.find_successor()
self.delete_node(replace_node)
if node.parent==None:
self.value=replace_node.value
self =replace_node
elif node.parent.left==node:
node.parent.left=replace_node
replace_node.parent=node.parent
else:
node.parent.right=replace_node
replace_node.parent=node.parent
elif node.left==None and node.right:
if node.parent!=None:
if node.parent.left==node:
node.parent.left=node.right
node.right.parent=node.parent
else:
node.parent.right=node.right
node.right.parent=node.parent
else:
node=node.right
elif node.left!=None and node.right==None:
if node.parent!=None:
if node.parent.left==node:
node.parent.left=node.left
node.left.parent=node.parent
else:
node.parent.right=node.left
node.left.parent=node.parent
else:
node=node.left
root=Binarytree('D',Binarytree('B',Binarytree('A'),Binarytree('C')),Binarytree('E',right=Binarytree('G',Binarytree('F'))))
root.preTraverse()
print()
root.midTraverse()
print()
root.lastTraverse()
print()
print(root.search('A'))
print(root.search('H'))
print(root.get_maximun())
print(root.get_minimun())
print(root.findvalue_successor('F').value)
root.insert_value('H')
print(root.get_maximun().value)
root.delete_value('D')
print("-------------")
root.preTraverse()