1.什么是二叉搜索树（BinarySearchTrees）
如下图所示：15为树的根节点，10为15的左节点，20为15的右节点，下面的节点如此类推。
每个父节点都有两个子节点（子节点可能为空），左子节点比父节点小，右子节点比父节点大。
2.二叉搜索树的各种功能
一、节点
每个节点应该含有两个子节点，一个可以进行比较的key（本文使用的是int）。节点可以根据需求来含有其它附属内容，本文为了方便测试，节点含有一个String和记录该节点下面共有多少个节点（包括自己）的Count。
节点实现：
UCLASS() class ALGORITHM_API ATreeNode : public AActor { GENERATED_BODY() public: // Sets default values for this actor's properties ATreeNode(); // Called every frame virtual void Tick(float DeltaTime) override; //设值 FORCEINLINE void SetValue(int Newkey, FString NewValue) { Key = Newkey; Value = NewValue; } FORCEINLINE ATreeNode* Get() { return this; } //获取或修改私有变量 FORCEINLINE int GetKey() { return Key; } FORCEINLINE void SetKey(int NewKey) { Key = NewKey; } FORCEINLINE int GetCount() { return Count; } FORCEINLINE void SetCount(int NewCount) { Count = NewCount; } FORCEINLINE FString GetValue() { return Value; } FORCEINLINE void SetValue(FString NewValue) { Value = NewValue; } FORCEINLINE ATreeNode* GetNode(bool Left) { if (Left) return LeftNode; return RightNode; } FORCEINLINE void SetNode(bool Left, ATreeNode* NewNode) { if (Left) LeftNode = NewNode; else { RightNode = NewNode; } } protected: // Called when the game starts or when spawned virtual void BeginPlay() override; private: int Key; FString Value; //左右节点 ATreeNode* LeftNode; ATreeNode* RightNode; //计算此节点下面共用多少个节点（包括自己） int Count; };
二、查找
如果想查找某个数字X，从根节点开始比较。如果X比根节点大，则去与根节点的右节点比较，如此类推，直到找到X（或子节点为空）为止。
例如上图二叉搜索树中，如果想找25：
从根节点开始比较：25>15。去根节点右边，与下一个节点（20）比较，结果25>20。接着去右边，与下一个节点（25）比较，结果25=25，查找成功。
代码实现：
FString ABinarySearchTrees::GetValue(int InputKey) { ATreeNode* X = RootNode; while (X != nullptr) { //比较key的大小 int Temp = CompareTo(InputKey, X->GetKey()); //如果输入的key比X的小，去X的左边 if (Temp < 0) X = X->GetNode(true); //如果输入的key比X的大，去X的右边 else if (Temp > 0) X = X->GetNode(false); //如果相等，说明找到这个key了，输出Value else return X->GetValue(); } //如果X为空指针，说明找不到这个key return "NotFind"; }
三、插入新节点
如果新节点的key在树中已经存在，则把旧节点覆盖；如果没有，则插入。
与查找类似，设新节点的key为X，从根节点开始比较。如果X比根节点大，则去与根节点的右节点比较。如此类推，如果找到了某个节点的key与X相同，覆盖这个节点；如果没找到，则根据最后一次比较结果，插到最后一次比较的节点的左节点或右节点。
实现代码:
void ABinarySearchTrees::Put(int Newkey) { //每次插入前，都清空路线信息 RouteString = ""; //每次插入新节点都要更新根节点 RootNode = Put(RootNode, Newkey); RootNode->SetValue(": Root"); } ATreeNode* ABinarySearchTrees::Put(ATreeNode* X, int NewKey) { //如果X不存在，创造一个 if (!X) { ATreeNode* NewNode = GetWorld()->SpawnActor(ATreeNode::StaticClass()); NewNode->SetValue(NewKey, RouteString); //节点存起来，方便测试 NodeArray.Add(NewNode); //新节点自己算一个节点 NewNode->SetCount(1); return NewNode; } int Temp = CompareTo(NewKey, X->GetKey()); //如果要插入新节点，则新节点的所有父节点都要更新一次 if (Temp < 0) { RouteString.Append(": Left"); X->SetNode(true, Put(X->GetNode(true), NewKey)); } else if (Temp > 0) { RouteString.Append(": Right"); X->SetNode(false, Put(X->GetNode(false), NewKey)); } else { X->SetValue(RouteString); } //更新X节点的Count X->SetCount(1 + Size(X->GetNode(true)) + Size(X->GetNode(false))); return X; }
四、查找最小值、最大值
查找最小值：因为二叉搜索树中，左节点比父节点小，故最小值肯定在树的左下角。从根节点开始，判断它的左节点存不存在。如果存在，继续找这个左节点的左节点，如此类推，直到找到某个节点的左节点不存在时，此节点就是最小值。
查找最大值：因为二叉搜索树中，右节点比父节点大，故最大值肯定在树的右下角。从根节点开始，判断它的右节点存不存在。如果存在，继续找这个右节点的右节点，如此类推，直到找到某个节点的右节点不存在时，此节点就是最大值。
实现代码：
//寻找最小值 int ABinarySearchTrees::FindMin() { //从根节点开始比较 ATreeNode* X = FindMin(RootNode); if (X) return X->GetKey(); return 0; } //寻找拥有最小值的节点 ATreeNode* ABinarySearchTrees::FindMin(ATreeNode* X) { //当节点存在时 while (X) { //如果右节点存在，继续循环 if (X->GetNode(true)) { X = X->GetNode(true); } //如果右节点不存在，这个节点就是最小值 else { return X; } } return X; } int ABinarySearchTrees::FindMax() { //从根节点开始比较 ATreeNode* X = FindMax(RootNode); if (X) return X->GetKey(); return 0; } //寻找拥有最大值的节点 ATreeNode* ABinarySearchTrees::FindMax(ATreeNode* X) { //当节点存在时 while (X) { //如果右节点存在，继续循环 if (X->GetNode(false)) { X = X->GetNode(false); } //如果右节点不存在，这个节点就是最小值 else { return X; } } return X; }
五、给定一个key，寻找最接近它的节点
Floor:最接近此key,且小于等于它的节点。
Ceiling:最接近此key,且大于等于它的节点。
寻找Floor：从下面的例子中介绍思路
假设给定key为X，现有搜索树如下图
假设X=13：
1.从根节点开始比较，X比19小，去19节点的左边。
2.X>10，但由于最接近X的节点可能在10的右节点下面，故还需去10的右边继续找。
3.X<14, 去14的左边。
4.X>12,且12没子节点，故12就是X的Floor。
假设X=11:
1.从根节点开始比较，X比19小，去19节点的左边。
2.X>10，但由于最接近X的节点可能在10的右节点下面，故还需去10的右边继续找。
3.X<14, 去14的左边。
4.X<12,且12没左子节点，故10的右节点下面没有比X小的节点，10就是X的Floor。
思路：
1.X与根节点比较，如果X小，去根节点的左节点，继续比较，直到找到一个比X小的节点A为止。
2.去A节点的右节点找比X小的节点。如果找不到，A就是要找的节点；如果找到了，令此节点为B，判断B节点是否有右节点，如果有，重复步骤2；如果没有，B节点就是要找的节点。
寻找Ceiling的过程与Floor类似，在此不累赘。
实现代码：
//给定一个数字，寻找最接近它的key(比它小) int ABinarySearchTrees::FindFloor(int InputKey) { //从根节点开始比较 ATreeNode* X = FindFloor(RootNode,InputKey); if (X) return X->GetKey(); return 0; } ATreeNode* ABinarySearchTrees::FindFloor(ATreeNode* X, int InputKey) { //如果X节点不存在，就别继续下去了 if (!X) return nullptr; int Temp = CompareTo(InputKey, X->GetKey()); //如果存在节点的key与输入值相等，则这个节点就是最接近它了 if (Temp == 0) return X; //如果节点的key比较大，则去找它的左节点，直到找到小于等于输入值的节点为止 if (Temp < 0) return FindFloor(X->GetNode(true), InputKey); //如果节点的key比较小，则要找的节点可能在它的右节点的左端 ATreeNode* T = FindFloor(X->GetNode(false), InputKey); //如果找到了T,则说明找到了，返回T;如果找不到，说明X已经是最接近的了，返回X if (T) return T; else return X; } //给定一个数字，寻找最接近它的key(比它大) int ABinarySearchTrees::FindCeiling(int InputKey) { //从根节点开始比较 ATreeNode* X = FindCeiling(RootNode, InputKey); if (X) return X->GetKey(); return 0; } ATreeNode* ABinarySearchTrees::FindCeiling(ATreeNode* X, int InputKey) { //如果X节点不存在，就别继续下去了 if (!X) return nullptr; int Temp = CompareTo(InputKey, X->GetKey()); //如果存在节点的key与输入值相等，则这个节点就是最接近它了 if (Temp == 0) return X; //如果节点的key比较小，则去找它的右节点，直到找到大于等于输入值的节点为止 if (Temp > 0) return FindCeiling(X->GetNode(false), InputKey); //如果节点的key比较大，则要找的节点可能在它的左节点的左端 ATreeNode* T = FindCeiling(X->GetNode(true), InputKey); //如果找到了T,则说明找到了，返回T;如果找不到，说明X已经是最接近的了，返回X if (T) return T; else return X; }
六、给定一个keyX,求有多少个节点的key比X小（即求Rank(X)）
这里就会用到节点里的Count了。这个Count记录了该节点下面共有多少个节点（包括自己）。
从例子介绍思路：
假设给定key为X，现有搜索树如下图
假设X=13，令根节点为A节点
1.从A节点开始比较，X比19小，去19节点的左边。
2.X>10，此时10和10左节点以下的所有节点都比X小，因为10的右节点下面可能还有节点比K小，所以还需要继续找，假设还有Y个节点在下面，则Rank(X)=1+4.Count+Y
3.X<14, 去14的左边。
4.X>12,且12没子节点，故Y=12.Count=1，Rank(X)=1+4.Count+Y=1+3+1=5。
思路：
令根节点为A节点
1. 从A节点开始比较：
如果X 如果X=A.key，则由于A的右节点下方都比A大，A的左节点下方都比A小，所以Rank(X)=A的左节点的Count； 如果X>A.key，则Rank(X)=1 + A的左节点的Count + A的右节点下方小于X的节点个数，进入步骤2。 2. 令A的右节点为A，重复步骤1。 3. 此循环结束后，便得到Rank(X)。 实现代码： 通过对二叉搜索树进行中序排列，可以得到一个递增的有序数组。对某个节点进行中序排列就是先排此节点的左节点，再排这个节点，最后排此节点的右节点。 例如对下图的节点4进行中序排列：2,4,7。 如果要对一个大节点排序，如下图： 对节点10进行中序排列：需要先对节点4进行中序排列，然后排10，再对节点14进行中序排列 同样道理，对根节点排序（即整个二叉搜索树进行中序排列）： 对节点19进行中序排列：需要先对节点10进行中序排列，然后排19，再对节点25进行中序排列 实现代码： 要删除一个节点，可能会遇到3种情况: A. 这个节点没子节点，此情况最为简单，直接删除这个节点即可。 B. 这个节点只有一个子节点，把这个子节点和这个节点的父节点相连，然后删除这个节点 C. 这个节点有两个子节点，此情况最为复杂，稍后讨论 举个例子： 如果要删除节点2，则就是A情况，直接删除即可； 如果要删除节点4，则就是B情况，由于4节点是10节点的左节点，故把节点2放在节点10的左节点处，然后删除节点4。 如果要删除节点10，则就是C情况，首先，我们需要从节点10下面找一个节点X来代替它，如下图所示： 可以看出X肯定比4大，比14小。故X只能从14的下面去找。显然，在此例子中X=12。替代了后，我们当然需要把14的左节点删掉，替换效果： 为了更直观的讨论，我们不妨将此树拓展一下： 删除节点10后： 此时，X肯定比4大，比14小，X的候选者有11,12,13。 不能选12，因为12有两个节点，处理起来过于复杂，且会破坏二叉搜索树的结构 11可以选，处理起来最简单。 不能选13，因为如果X=13，就会破坏了二叉搜索树的结构，如下图： 在二叉搜索树的结构中，父节点应该比它的右节点下面的所有节点都小。而此例子中，13>12>11。 选择11时，X=11，删除节点成功，如下图 因此，回到情况C:这个节点有两个子节点，要删除它的操作是： 1. 从此节点的右节点下面找出最小的节点X。 2. 因为X节点是最小的，所以它的子节点数量肯定小于等于1个，把此子节点连到X的父节点上。 3. 然后用X节点替换要删除的节点。 4. 删除要删除的节点。 至于怎么删除最小节点，上面已经介绍了如何找到最小节点，要删除它只需在此基础上进行少量操作。 实现代码： //求有多少个数字少于给定数字
int ABinarySearchTrees::Rank(int InputKey)
{
return Rank(InputKey, RootNode);
}
int ABinarySearchTrees::Rank(int InputKey, ATreeNode* X)
{
//如果节点不存在，返回0
if (!X) return 0;
int Temp = CompareTo(InputKey, X->GetKey());
//如果给定数字比X的key小，则去X的左边去找比给定数字小的数字
if (Temp < 0) return Rank(InputKey, X->GetNode(true));
//如果给定数字比X的key大，则X和X的左节点都比给定数字小，把它们算上后，去X的右节点找是否还有比给定数字小的数字
else if (Temp > 0) return 1 + Size(X->GetNode(true)) + Rank(InputKey, X->GetNode(false));
//因为右节点都比X大，而X的Key与给定数字相等，故比给定数字小的数字都在X的左节点里
else return Size(X->GetNode(true));
}
七、中序排列
void ABinarySearchTrees::InorderTraversal()
{
OrderNodeArray.Empty();
Inorder(RootNode);
}
void ABinarySearchTrees::Inorder(ATreeNode* X)
{
if (!X) return;
//先去加X的左节点
Inorder(X->GetNode(true));
//再加X
OrderNodeArray.Add(X->GetKey());
//最后加X的右节点
Inorder(X->GetNode(false));
}
八、删除节点
//删除最小的节点
void ABinarySearchTrees::DeleteMin()
{
RootNode = DeleteMin(RootNode);
}
ATreeNode* ABinarySearchTrees::DeleteMin(ATreeNode* X)
{
//如果X的左节点不存在，说明已经找到最小值了，删除它，返回它的右节点
if (!X->GetNode(true))
{
ATreeNode* TempNode = X->GetNode(false);
NodeArray.Remove(X);
X->Destroy();
return TempNode;
}
//删除最小值后，把它的右节点和上一个节点连上
X->SetNode(true, DeleteMin(X->GetNode(true)));
//更新节点数
X->SetCount(1 + Size(X->GetNode(true)) + Size(X->GetNode(false)));
return X;
}
void ABinarySearchTrees::Delete(int InputKey)
{
RootNode = Delete(RootNode, InputKey);
}
ATreeNode* ABinarySearchTrees::Delete(ATreeNode* X, int InputKey)
{
if (!X) return nullptr;
int Temp = CompareTo(InputKey, X->GetKey());
//寻找要删除的节点，只要删了一个节点，它上面的所有节点都要更新一次，所以是SetNode
if (Temp < 0) X->SetNode(true, Delete(X->GetNode(true), InputKey));
else if (Temp > 0) X->SetNode(false, Delete(X->GetNode(false), InputKey));
//找到要删除的节点了
else
{
//如果要删除的节点只有一个子节点或没有，那好办，只需把那个子节点替代它就好
if (!X->GetNode(false))
{
ATreeNode* TempNode = X->GetNode(true);
NodeArray.Remove(X);
X->Destroy();
return TempNode;
}
if (!X->GetNode(true))
{
ATreeNode* TempNode = X->GetNode(false);
NodeArray.Remove(X);
X->Destroy();
return TempNode;
}
//如果要删除的节点有两个个子节点，从它的右边找一个最小的节点来替代它
ATreeNode* T = X;
X = FindMin(T->GetNode(false));
X->SetNode(false, DeleteMin(T->GetNode(false)));
X->SetNode(true, T->GetNode(true));
NodeArray.Remove(T);
T->Destroy();
}
//更新节点数
X->SetCount(Size(X->GetNode(true)) + Size(X->GetNode(false)) + 1);
return X;
}
九、完整的全部代码
节点.h:
UCLASS()
class ALGORITHM_API ATreeNode : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
ATreeNode();
// Called every frame
virtual void Tick(float DeltaTime) override;
//设值
FORCEINLINE void SetValue(int Newkey, FString NewValue)
{
Key = Newkey;
Value = NewValue;
}
FORCEINLINE ATreeNode* Get() { return this; }
//获取或修改私有变量
FORCEINLINE int GetKey() { return Key; }
FORCEINLINE void SetKey(int NewKey) { Key = NewKey; }
FORCEINLINE int GetCount() { return Count; }
FORCEINLINE void SetCount(int NewCount) { Count = NewCount; }
FORCEINLINE FString GetValue() { return Value; }
FORCEINLINE void SetValue(FString NewValue) { Value = NewValue; }
FORCEINLINE ATreeNode* GetNode(bool Left)
{
if (Left) return LeftNode;
return RightNode;
}
FORCEINLINE void SetNode(bool Left, ATreeNode* NewNode)
{
if (Left) LeftNode = NewNode;
else
{
RightNode = NewNode;
}
}
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
private:
int Key;
FString Value;
//左右节点
ATreeNode* LeftNode;
ATreeNode* RightNode;
//计算此节点下面共用多少个节点（包括自己）
int Count;
};
二叉搜索树.h:
class ATreeNode;
UCLASS()
class ALGORITHM_API ABinarySearchTrees : public AActor
{
GENERATED_BODY()
public:
// Sets default values for this actor's properties
ABinarySearchTrees();
// Called every frame
virtual void Tick(float DeltaTime) override;
//查值
FString GetValue(int InputKey);
//某个key是否存在？
bool Search(int InputKey);
//插入一个节点
void Put(int Newkey);
ATreeNode* Put(ATreeNode* X, int NewKey);
//提供一个方法让TreeNode之间进行比较
//如果a大于b，返回1；如果a小于b，返回-1；如果相等，返回0
int CompareTo(int a, int b);
//寻找最小值
int FindMin();
//寻找拥有最小值的节点
ATreeNode* FindMin(ATreeNode* X);
//寻找最大值
int FindMax();
//寻找拥有最大值的节点
ATreeNode* FindMax(ATreeNode* X);
//给定一个数字，寻找最接近它的key(比它小)
int FindFloor(int InputKey);
ATreeNode* FindFloor(ATreeNode* X, int InputKey);
//给定一个数字，寻找最接近它的key(比它大)
int FindCeiling(int InputKey);
ATreeNode* FindCeiling(ATreeNode* X, int InputKey);
//求有多少个数字少于给定数字
int Size(ATreeNode* X);
int Rank(int InputKey);
int Rank(int InputKey, ATreeNode* X);
//中序遍历
void InorderTraversal();
void Inorder(ATreeNode* X);
//删除最小值
void DeleteMin();
ATreeNode* DeleteMin(ATreeNode* X);
//删除某个节点
void Delete(int InputKey);
ATreeNode* Delete(ATreeNode* X, int InputKey);
protected:
// Called when the game starts or when spawned
virtual void BeginPlay() override;
public:
private:
//根节点
ATreeNode* RootNode;
//节点数组
TArray