一、性质
二叉搜索树是一种特殊的二叉树,其性质如下:
- 每一个节点的左子树的所有节点都比该节点小。
- 每一个节点的右子树的所有节点都比该节点大。
- 任意一颗子树也是二叉搜索树。
二、操作
2.1 查找
在二叉查找树b中查找x的过程为:
- 若b是空树,则搜索失败,否则:
- 若x等于b的根节点的数据域之值,则查找成功;否则:
- 若x小于b的根节点的数据域之值,则搜索左子树;否则:
- 查找右子树。
c#代码如下
public class TreeNode
{
public int Data = 1;
public TreeNode LeftNode;
public TreeNode RightNode;
public TreeNode(int data)
{
Data = data;
}
}
public class NodeTestTree
{
private TreeNode m_RootTreeNode;
public TreeNode Find(int targetData)
{
return FindBST(m_RootTreeNode, targetData);
}
private TreeNode FindBST(TreeNode root, int targetData)
{
if (root == null)
{
// 节点没有,返回空
return null;
}
else if (root.Data == targetData)
{
// 找到了
return root;
}
else if (targetData < root.Data)
{
// 搜索左子树
return FindBST(root.LeftNode, targetData);
}
else
{
// 搜索右子树
return FindBST(root.RightNode, targetData);
}
}
}
2.2 插入
- 若根节点为空,设置新插入的值为根节点
- 把根节点作为查找节点,如果查找节点的值与新值相同,返回错误
- 判断新值与节点值大小
- 如果新值小于节点值,则判断是否有左子节点,如果没有设为该节点的左子节点,如果有,把左子节点作为查找节点,重复2
- 如果新值小大节点值,则判断是否有右子节点,如果没有设为该节点的右子节点,如果有,把右子节点作为查找节点,重复2
public class NodeTestTree
{
private TreeNode m_RootTreeNode;
public TreeNode Insert(int data)
{
// 整棵树不存在,新建这颗树
if (m_RootTreeNode == null)
{
m_RootTreeNode = new TreeNode(data);
return m_RootTreeNode;
}
return InnerInsert(m_RootTreeNode, data);
}
// 内部递归用
private TreeNode InnerInsert(TreeNode parentNode, int data)
{
if (parentNode.Data == data)
{
// 不能有相同的数据
return null;
}
else if (data < parentNode.Data)
{
// 新值小于该节点的值,找左子节点
TreeNode leftNode = parentNode.LeftNode;
if (leftNode == null)
{
// 没有就新建
leftNode = new TreeNode(data);
// 建立引用关系
parentNode.LeftNode = leftNode;
// 返回数据
return leftNode;
}
else
{
// 继续找左子节点下面的节点
return InnerInsert(leftNode, data);
}
}
else
{
TreeNode rightNode = parentNode.RightNode;
if (rightNode == null)
{
// 没有就新建
rightNode = new TreeNode(data);
// 建立引用关系
parentNode.RightNode = rightNode;
// 返回数据
return rightNode;
}
else
{
// 继续找右子节点下面的节点
return InnerInsert(rightNode, data);
}
}
}
}
2.3 删除
- 若被删除节点N是叶子节点,只需修改父节点P的左子节点(N是P的左子节点)或者右子节点(N是P的右子节点)为空即可。
- 若被删除节点N只有左子节点NL或者右子节点NR,此时只需要令NL或NR直接成为N的父节点P的左子节点(N是P的左子节点)或者右子节点(N是P的右子节点)即可。
- 若被删除点N的左子节点NL和右子节点NR均不为空。在删去节点N后,为保持其他元素之间的相对位置不变,可按中序遍历保持有序进行调整。
3.1 找到以NL为树根,这棵树的最右下节点S,S的父节点SP,S的左子节点SL。
3.2 令N的值,等于S的值。
3.3 令S的左子节点为null。
3.4 如果S不等于NL,令SP的右子节点等于SL。如果S等于NL,令SP的左子节点等于SL。
c#语言版本:在C#里,删除节点即断开父节点与该节点的引用关系,以及该节点与子节点的引用关系。
- 树的根节点是否存在,不存在返回false
- 根据传入值,找到值相同的节点N、其父节点P、引用关系(N是F的左子节点还是右子节点),若节点N不存在,返回false
- 若节点N为叶子节点,断开NF的引用关系。若F为空,根节点置为空。相当于这棵树只有一个根节点,删除了整棵树。
- 若节点N只有左子节点NL,F的引用关系到NL,N的左子节点置为空。如F为空,根节点的指向NL。
- 若节点N只有右子节点NR,F的引用关系到NR,N的右子节点置为空。如F为空,根节点的指向NR。
- 若节点N同时拥有左子节点NL和右子节点NR,
3.1 找到以NL为树根,这棵树的最右下节点S,S的父节点SP,S的左子节点SL。
3.2 令N的值,等于S的值。
3.3 令S的左子节点为null。
3.4 如果S不等于NL,令SP的右子节点等于SL。如果S等于NL,令SP的左子节点等于SL。
c#代码实现:
#region 删除节点
private class NodeRef
{
public TreeNode ParentNode;
public TreeNode ChildNode;
public bool IsLeft;
}
private NodeRef FindRef(int targetData)
{
return FindRefBST(m_RootTreeNode, targetData);
}
private NodeRef FindRefBST(TreeNode root, int targetData, TreeNode parentNode = null, bool isLeft = false)
{
if (root == null)
{
// 节点没有,返回空
return null;
}
else if (root.Data == targetData)
{
// 找到了
NodeRef ret = new NodeRef();
ret.ParentNode = parentNode;
ret.ChildNode = root;
ret.IsLeft = false;
return ret;
}
else if (targetData < root.Data)
{
// 搜索左子树
return FindRefBST(root.LeftNode, targetData, root, true);
}
else
{
// 搜索右子树
return FindRefBST(root.RightNode, targetData, root, false);
}
}
public bool Delete(int targetData)
{
if (m_RootTreeNode == null) // 树不存在
{
return false;
}
NodeRef nodeRef = FindRef(targetData);
if (nodeRef == null) // 节点不存在
{
return false;
}
TreeNode NNode = nodeRef.ChildNode;
if (NNode.LeftNode == null && NNode.RightNode == null) // N为叶子节点
{
SetParentAndChild(nodeRef, null);
}
else if (NNode.LeftNode != null && NNode.RightNode == null)
{
SetParentAndChild(nodeRef, NNode.LeftNode);
}
else if (NNode.LeftNode == null && NNode.RightNode != null)
{
SetParentAndChild(nodeRef, NNode.RightNode);
}
else // 同时拥有左子节点NL和右子节点NR
{
TreeNode SPNode = NNode;
TreeNode SNode = NNode.LeftNode;
while (SNode.RightNode != null)
{
SPNode = SNode;
SNode = SNode.RightNode;
}
TreeNode SLNode = SNode.LeftNode;
NNode.Data = SNode.Data;
SNode.LeftNode = null;
if (SNode.Data != NNode.LeftNode.Data)
{
SPNode.RightNode = SLNode;
}
else
{
SPNode.LeftNode = SLNode;
}
}
return true;
}
private void SetParentAndChild(NodeRef nodeRef, TreeNode grandchild)
{
if (nodeRef.ParentNode == null)
{
// 删除的是根节点,需要设置根节点
m_RootTreeNode = grandchild;
}
else
{
if (nodeRef.IsLeft)
{
nodeRef.ParentNode.LeftNode = grandchild;
}
else
{
nodeRef.ParentNode.RightNode = grandchild;
}
}
}
#endregion
2.4 遍历:
这里用中序遍历:
public void TraverseTree()
{
InnerTraverse(m_RootTreeNode);
}
private void InnerTraverse(TreeNode node)
{
if (node == null)
{
return;
}
InnerTraverse(node.LeftNode);
Debug.LogError(node.Data);
InnerTraverse(node.RightNode);
}
2.5 排序(或称构造)
public NodeTestTree(List<int> datas)
{
for (int i = 0; i < datas.Count; i++)
{
Insert(datas[i]);
}
}
用一组数值建造一颗二叉查找树的同时,也把这组数值进行了排序,其最差时间复杂度为
O
(
n
2
)
O(n^2)
O(n2)。
例如:若该组数值已经是有序的(从小到大),则建造出来的二叉查找树的所有节点,都没有左子树。
三、性能分析
- 最坏情况下,当先后插入的关键字有序时,构成的二叉查找树蜕变为单支树,树的深度为n,其平均查找长度为 n + 1 2 \frac{n+1}{2} 2n+1(和顺序查找相同),最好的情况是二叉树的形态和折半查找的判定树相同,其平均查找长度和 l o g 2 ( n ) log_2(n) log2(n)成正比 O ( l o g 2 ( n ) ) O(log_2(n)) O(log2(n))。
- 树排序的问题使得CPU Cache性能较差,特别是当节点是动态内存分配时,而堆排序的CPU Cache性能较好。
- 树排序是最优的增量排序算法,保持一个数值序列的有序性。
四、优化
一般的二叉查找树的查询复杂度取决于目标结点到树根的距离(即深度),因此当结点的深度普遍较大时,查询的均摊复杂度会上升。为了实现更高效的查询,产生了平衡树
。在这里,平衡指所有叶子的深度趋于平衡,更广义的是指在树上所有可能查找的均摊复杂度偏低。