二分搜索树
算法思路
根据《算法导论》提供的思路实现代码，只有插入函数与删除函数相对更加复杂一些。由于是动态的，必须修改数据结构来反映变化。对于插入来说，需要从树根开始利用指针x记录一条向下的简单路径并查找要替换的输入项z的空位nullptr。对于删除来说，需要分三种情况讨论并实现一个子过程：两颗子树的交换并调整双亲——TRANSPLANT
程序设计框架
以下为源码中主要结构和函数的解释与说明：
- 宏test_index
为了检测各个函数的功能,选取初始数据中的一个节点进行验证,宏给出的即为某个下标。这个下标的选择可以根据需求更改。初始数据规模为20个节点（data[20]），Test-Node即为data[test_index%20] - 核心类mynode
表示二叉搜索树中的一个节点，包含了关键字key、值value、左右儿子指针、父指针。 - 核心类mytree
包含一个int类型变量num用于记录当前树中含有的节点个数以及一个mynode*类型的指针root指向该树的根节点。 - void INORDER_TREE_WALK(mynode *x);
中序遍历输出函数，参数为开始输出的起始节点。 - void TREE_INSERT(mytree *tree, mynode *z);
插入函数，*tree为所要插入的目标树，z为所要插入的节点。 - void TREE_DELETE(mytree *tree, mynode *z);
删除函数，*tree为所要删除的目标树，z为所要删除的节点。 - void TRANSPLANT(mytree *tree, mynode *u, mynode *v);
交换树函数，用一颗子树替换另一颗子树并成为其双亲的孩子节点，u、v为两颗子树的根节点，这是delete函数的一个子过程，为其重要组成部分。 - mynode *TREE_MINIMUM(mynode *z);
以节点z为根节点查找具有最小key值的节点并返回之。 - mynode *TREE_MAXIMUM(mynode *x);
以节点z为根节点查找具有最大key值的节点并返回之。 - mynode *TREE_SUCCESSOR(mynode *x);
查找节点x的后继节点，若没有则返回nullptr。 - mynode *TREE_PREDECESSOR(mynode *x);
查找节点x的前驱节点，若没有则返回nullptr。 - mynode *ITERATIVE_TREE_SEARCH(mynode *x, int key);
迭代法从上至下查找某个节点，注意对比key值。
实验进行了小范围的验证，并在各个函数中都加入了输出提示性语句的相关代码，可根据提示性代码检验相关函数功能的正确性。
实验结果说明
某次测试输出结果如下：
Initial Tree:
5 7 9 12 16 18 21 21 24 27 38 41 44 47 55 59 64 69 71 82
Tree root: 7
Max of all: 82
Min of all: 5
Test-Node: 44
Test-Node's successor: 47
Test-Node's predecessor: 41
After delete Test-Node:
5 7 9 12 16 18 21 21 24 27 38 41 47 55 59 64 69 71 82
输入的节点数据由rand()随机产生（只对key进行了赋值，范围0~100，value备用），初始数据规模为20，可根据需求修改
第二行输出的是20个数据全部INSERT之后、中序遍历的结果
第三行为根节点的key值
第四、五行为调用TREE_MAXIMUN和TREE_MINIMUM函数之后输出的最值
第六行为根据宏test_index选出的测试节点的key值，测试节点可根据需求修改
第七、八行为后继和前驱节点（若前驱后继不存在则会输出相关提示性语句）
第十行为删去该测试节点后中序遍历的结果
以下为类似的测试输出结果
Initial Tree:
8 12 13 18 21 27 28 28 36 40 43 51 60 60 64 67 78 85 95 96
Tree root: 12
Max of all: 96
Min of all: 8
Test-Node: 8
Test-Node's successor: 12
Test-Node is the smallest!
After delete Test-Node:
12 13 18 21 27 28 28 36 40 43 51 60 60 64 67 78 85 95 96
Initial Tree:
8 33 37 37 39 44 45 53 57 62 62 70 71 72 79 81 88 94 96 98
Tree root: 94
Max of all: 98
Min of all: 8
Test-Node: 98
Test-Node is the biggest!
Test-Node's predecessor: 96
After delete Test-Node:
8 33 37 37 39 44 45 53 57 62 62 70 71 72 79 81 88 94 96
完整源码
#include <stdio.h>
#include <time.h>
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#define test_index 13
using namespace std;
struct mynode
{
int key = 0;
int value = 0;
mynode *parent = nullptr;
mynode *l_child = nullptr;
mynode *r_child = nullptr;
};
struct mytree
{
int num = 0;
mynode *root = nullptr;
};
void INORDER_TREE_WALK(mynode *x);
void TREE_INSERT(mytree *tree, mynode *z);
void TREE_DELETE(mytree *tree, mynode *z);
void TRANSPLANT(mytree *tree, mynode *u, mynode *v);
mynode *TREE_MINIMUM(mynode *z);
mynode *TREE_MAXIMUM(mynode *x);
mynode *TREE_SUCCESSOR(mynode *x);
mynode *TREE_PREDECESSOR(mynode *x);
mynode *ITERATIVE_TREE_SEARCH(mynode *x, int key);
int main()
{
srand((unsigned)(time(NULL)));
int ti = test_index % 20;
mytree *test;
mynode data[20];
for (int i = 0; i < 20; i++)
{
data[i].key = rand() % 100;
TREE_INSERT(test, &data[i]);
}
cout << endl
<< "Initial Tree:" << endl;
INORDER_TREE_WALK(test->root);
cout << endl;
cout << "Tree root: " << test->root->key << endl;
mynode *max = TREE_MAXIMUM(test->root);
mynode *min = TREE_MINIMUM(test->root);
cout << "Max of all: " << max->key << endl;
cout << "Min of all: " << min->key << endl;
cout << "Test-Node: " << data[ti].key << endl;
mynode *s = TREE_SUCCESSOR(&data[ti]);
mynode *p = TREE_PREDECESSOR(&data[ti]);
if (s != nullptr)
cout << "Test-Node's successor: " << s->key << endl;
else
cout << "Test-Node is the biggest!" << endl;
if (p != nullptr)
cout << "Test-Node's predecessor: " << p->key << endl;
else
cout << "Test-Node is the smallest!" << endl;
TREE_DELETE(test, &data[ti]);
cout << "After delete Test-Node:" << endl;
INORDER_TREE_WALK(test->root);
cout << endl;
}
void INORDER_TREE_WALK(mynode *x)
{
if (x != nullptr)
{
INORDER_TREE_WALK(x->l_child);
cout << x->key << " ";
INORDER_TREE_WALK(x->r_child);
}
}
void TREE_INSERT(mytree *tree, mynode *z)
{
mynode *x = tree->root;
mynode *y = nullptr;
while (x != nullptr)
{
y = x;
if (z->key < x->key)
x = x->l_child;
else
x = x->r_child;
}
z->parent = y;
if (y == nullptr)
{
tree->root = z;
}
else if (z->key < y->key)
y->l_child = z;
else
y->r_child = z;
tree->num++;
}
void TRANSPLANT(mytree *tree, mynode *u, mynode *v)
{
if (u->parent == nullptr)
tree->root = v;
else if (u == u->parent->l_child)
u->parent->l_child = v;
else
u->parent->r_child = v;
if (v != nullptr)
v->parent = u->parent;
}
void TREE_DELETE(mytree *tree, mynode *z)
{
if (z->l_child == nullptr)
TRANSPLANT(tree, z, z->r_child);
else if (z->r_child == nullptr)
{
TRANSPLANT(tree, z, z->l_child);
}
else
{
mynode *y = TREE_MINIMUM(z->r_child);
if (y->parent != z)
{
TRANSPLANT(tree, y, y->r_child);
y->r_child = z->r_child;
y->r_child->parent = y;
}
TRANSPLANT(tree, z, y);
y->l_child = z->l_child;
y->l_child->parent = y;
}
tree->num--;
}
mynode *TREE_MINIMUM(mynode *x)
{
while (x->l_child != nullptr)
{
x = x->l_child;
}
return x;
}
mynode *TREE_MAXIMUM(mynode *x)
{
while (x->r_child != nullptr)
{
x = x->r_child;
}
return x;
}
mynode *ITERATIVE_TREE_SEARCH(mynode *x, int key)
{
while (x != nullptr && x->key != key)
{
if (x->key > key)
x = x->l_child;
else
x = x->r_child;
}
return x;
}
mynode *TREE_SUCCESSOR(mynode *x)
{
if (x->r_child != nullptr)
return TREE_MINIMUM(x->r_child);
mynode *y = x->parent;
while (y != nullptr && x == y->r_child)
{
x = y;
y = y->parent;
}
return y;
}
mynode *TREE_PREDECESSOR(mynode *x)
{
if (x->l_child != nullptr)
return TREE_MAXIMUM(x->l_child);
mynode *y = x->parent;
while (y != nullptr && x == y->l_child)
{
x = y;
y = y->parent;
}
return y;
}
红黑树的插入操作
算法思路
为了完成插入操作，必须在二分搜索树的INSERT函数基础之上进行颜色和结构修正，重点在于RB_INSERT_FIXUP函数的实现上。
为了保持红黑树的性质，在插入到正确的位置并涂上初始颜色红色之后，需要分两种大情况讨论，其中第二种情况下又有三种小情况。具体实现过程中还必须认真考虑涉及到nil指针的相关操作，否则很容易出现segmentation fault的报错。
红黑树的前驱、后继、最大、最小等操作与二分搜索树几乎完全相同，本文将其略去。
程序设计框架
- class mynode
红黑树节点，封装了关键字、值、颜色、父节点、左右节点这几个关键数据 - class mytree
红黑树，包括了节点个数num、root指针、和nil指针，nil为黑色，同时必须注意初始化nil的父子指针，否则报错 - mynode *GetNode(const int &x = 0)
该函数用于申请得到一个节点并初始化，初始颜色为红色，初始父子节点均为nil，默认关键字初始值为0 - void TREE_INSERT(mynode *z)
插入函数，与二分搜索树的插入操作相差不多，为插入节点涂上初始颜色红色 - void RB_INSERT_FIXUP(mynode *z)
修正函数，用于纠正某些颜色和结构上的错误以保证红黑树的性质。分两种大情况讨论。若父节点为黑色，直接插入红色节点即可。若父节点为红色，则又可细分为：叔叔节点为红色或黑色讨论。若为红，则父辈节点与祖辈节点交换颜色。若为黑且为左儿子，需要进行一次右旋。若黑且为右儿子，需要进行先左后右两次旋转。当然需要分父节点为祖节点的左、右儿子节点两种情况具体讨论，这两种情况相对称，左右操作反过即可 - void LEFT_ROTATE(mynode *x)
左旋函数 - void RIGHT_ROTATE(mynode *x)void
右旋函数 - INORDER_TREE_WALK(mynode *x)
中序遍历函数，用于输出并观察、验证红黑树的结构
实验结果说明
某次测试输出结果如下：
Initial Tree:
2(R) 3(B) 3(R) 5(B) 5(B) 18(R) 20(R) 26(R) 31(B) 34(B) 40(B) 46(R) 66(R) 75(B) 77(B) 79(B) 80(B) 93(R) 97(B) 98(R)
Tree root: 77
输入的节点数据的key值由rand()随机产生（只对key进行了赋值，范围0~100，value备用），初始数据规模为20，可根据需求修改
输出的是20个数据全部INSERT之后、中序遍历的结果，其中每个数据之后均标出了关键字代表的节点相应的颜色。
最后一行输出了树根节点的key值。
完整源码
#include <stdio.h>
#include <time.h>
#include <iostream>
#include <stdlib.h>
#include <algorithm>
#define test_index 13
using namespace std;
enum color
{
RED,
BLACK
};
class mynode
{
public:
int key;
int value;
enum color nodecolor;
mynode *parent;
mynode *l_child;
mynode *r_child;
mynode()
{
key = 0;
value = 0;
nodecolor = RED;
}
};
class mytree
{
public:
int num = 0;
mynode *nil;
mynode *root;
mytree()
{
nil = GetNode();
nil->nodecolor = BLACK;
nil->r_child = nil;
nil->l_child = nil;
root = nil;
}
~mytree()
{
delete nil;
nil = NULL;
}
mynode *GetNode(const int &x = 0)
{
mynode *s = new mynode();
s->nodecolor = RED;
s->l_child = s->r_child = s->parent = nil;
s->key = x;
return s;
}
void TREE_INSERT(mynode *z)
{
mynode *x = root;
mynode *y = nil;
while (x != nil)
{
y = x;
if (z->key < x->key)
x = x->l_child;
else
x = x->r_child;
}
z->parent = y;
if (y == nil)
{
root = z;
}
else if (z->key < y->key)
y->l_child = z;
else
y->r_child = z;
num++;
z->l_child = nil;
z->r_child = nil;
z->nodecolor = RED;
RB_INSERT_FIXUP(z);
}
void RB_INSERT_FIXUP(mynode *z)
{
while (z->parent->nodecolor == RED)
{
if (z->parent == z->parent->parent->l_child)
{
mynode *y = z->parent->parent->r_child;
if (y->nodecolor == RED)
{
z->parent->nodecolor = BLACK;
y->nodecolor = BLACK;
z->parent->parent->nodecolor = RED;
z = z->parent->parent;
}
else
{
if (z == z->parent->r_child)
{
z = z->parent;
LEFT_ROTATE(z);
}
z->parent->nodecolor = BLACK;
z->parent->parent->nodecolor = RED;
RIGHT_ROTATE(z->parent->parent);
}
}
else
{
if (z->parent == z->parent->parent->r_child)
{
mynode *y = z->parent->parent->l_child;
if (y->nodecolor == RED)
{
z->parent->nodecolor = BLACK;
y->nodecolor = BLACK;
z->parent->parent->nodecolor = RED;
z = z->parent->parent;
}
else
{
if (z == z->parent->l_child)
{
z = z->parent;
RIGHT_ROTATE(z);
}
z->parent->nodecolor = BLACK;
z->parent->parent->nodecolor = RED;
LEFT_ROTATE(z->parent->parent);
}
}
}
}
root->nodecolor = BLACK;
}
void LEFT_ROTATE(mynode *x)
{
mynode *y = x->r_child;
x->r_child = y->l_child;
if (y->l_child != nil)
{
y->l_child->parent = x;
}
y->parent = x->parent;
if (root == x)
{
root = y;
}
else if (x == x->parent->l_child)
{
x->parent->l_child = y;
}
else
{
x->parent->r_child = y;
}
y->l_child = x;
x->parent = y;
}
void RIGHT_ROTATE(mynode *x)
{
mynode *y = x->l_child;
x->l_child = y->r_child;
if (y->r_child != nil)
{
y->r_child->parent = x;
}
y->parent = x->parent;
if (root == x)
{
root = y;
}
else if (x == x->parent->r_child)
{
x->parent->r_child = y;
}
else
{
x->parent->l_child = y;
}
y->r_child = x;
x->parent = y;
}
void INORDER_TREE_WALK(mynode *x)
{
if (x != nil)
{
INORDER_TREE_WALK(x->l_child);
cout << x->key << "(";
if (x->nodecolor == 0)
cout << "R";
else
cout << "B";
cout << ") ";
INORDER_TREE_WALK(x->r_child);
}
}
};
int main()
{
srand((unsigned)(time(NULL)));
mytree *test = new mytree();
mynode *data[20];
for (int i = 0; i < 20; i++)
{
data[i] = test->GetNode(rand() % 100);
// data[0]=test->GetNode(41);
// data[1]=test->GetNode(38);
// data[2]=test->GetNode(31);
// data[3]=test->GetNode(12);
// data[4]=test->GetNode(19);
// data[5]=test->GetNode(8);
test->TREE_INSERT(data[i]);
}
cout << endl << "Initial Tree:" << endl;
test->INORDER_TREE_WALK(test->root);
cout << endl << "Tree root: " << test->root->key << endl;
}
扫一扫
688
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
