一、性质
二叉搜索树是一种特殊的二叉树，其性质如下：
- 每一个节点的左子树的所有节点都比该节点小。
- 每一个节点的右子树的所有节点都比该节点大。
- 任意一颗子树也是二叉搜索树。
二、操作
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性能较好。
- 树排序是最优的增量排序算法，保持一个数值序列的有序性。
四、优化
一般的二叉查找树的查询复杂度取决于目标结点到树根的距离（即深度），因此当结点的深度普遍较大时，查询的均摊复杂度会上升。为了实现更高效的查询，产生了平衡树。在这里，平衡指所有叶子的深度趋于平衡，更广义的是指在树上所有可能查找的均摊复杂度偏低。
135
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
