算法导论 第14章 数据结构的扩张（三） 14.3-6 最小差幅树

题目



思考

为了加深对数据结构的扩张的理解，我们根据14.2给出的四个步骤一一来实践。

步骤1：选择基础树结构

显然，我们得选择红黑树作为基本数据结构了，每个节点除了和红黑树一样的域之外，还有一个minGap域，用于存储以该节点为根的子树的最小差幅。对于树根而言，minGap就是整棵树，即整个序列的最小差幅了。

步骤2：附加信息

minGap是最小差幅，因此为了便于维护以该节点为根的子树的最小差幅，我们再给每个节点增加一个min域和一个max域，前者用于存储该子树中的最小值，后者存储该子树的最大值，显然，前者只会出现在左子树或者本节点中，后者只会出现在右子树或者本节点中。

步骤3：对信息的维护

在数据的插入和删除中，找到特定位置需O(lgn)时间，然后自底向上维护，时间亦为O(lgn)。而对于每个节点中各信息域的维护，可以用以下函数实现：

void update(node *curr)
{//更新节点信息
//根据二叉查找树的性质可知无需考虑右子树
curr->min = (curr->left == nil) ? curr->key : curr->left->min;
curr->max = (curr->right == nil) ? curr->key : curr->right->max;
int leftMinGap = (curr->left == nil) ? MAX : curr->left->minGap;
int rightMinGap = (curr->right == nil) ? MAX : curr->right->minGap;
//当前节点与左子树差幅
int currLeftGap = (curr->left == nil) ? MAX : (curr->key - curr->left->max);
int currRightGap = (curr->right == nil) ? MAX : (curr->right->min - curr->key);
curr->minGap = Min4(leftMinGap, rightMinGap, currLeftGap, currRightGap);
}

该函数更新每个节点的信息只需要O(1)时间，因此整个插入或者删除的渐进时间没有改变，依然为O(lgn)。

步骤4：设计新操作

新操作除了步骤3介绍的update之外，还有获得整棵树minGap的操作以及自底向上更新信息的keep函数。keep函数代码如下：

void keep(node *curr)
{
while (curr != nil)
{
update(curr);
curr = curr->parent;
}
}

keep函数通常在删除或者插入数据后的自底向上的更新调用中，有别于之前的扩张中自上而下的更改信息。

有了上述的扩张——信息的添加和对信息有力的维护的操作，我们可以对之前的红黑树做些许更改即可实现一颗最小差幅树(Minimum Gap Tree)，获得整个序列的最小差幅操作minGap只需O(1)的时间。

下面是最小差幅树的C++实现代码：

/****最小差幅树，维持一个集合中最相近的两个数的差值(>=0)，红黑树扩张
*增加了minGap,min,max数据成员，其中min和max只是为了维护minGap而添加
*增加了update和keep以及minGap函数
*update在更新某节点信息，keep由底向上更新树节点信息
****/
#include<iostream>

using namespace std;
enum COLOR { red, black };//枚举，定义颜色
const int MAX = 0x7fffffff;

int Min4(int a, int b, int c, int d)
{//求四个数的最小值
a = a < b ? a : b;
c = c < d ? c : d;
return a < c ? a : c;
}

class node
{
private:
friend class MGTree;
node *parent;
node *left;
node *right;
int key;//关键字
int minGap;//以此节点为根的树的最小差幅
int min;//以此节点为根的树的最小值
int max;//以此节点为根的树的最大值
COLOR color;
node(){}//默认构造函数，只供创建nil时调用
public:
node(int k, COLOR c = red) :key(k), minGap(MAX), min(k), max(k),
color(c), parent(NULL), left(NULL), right(NULL){}
void print()const
{
printf("key:%-10dMinGap: %-15dmin: %-6dmax: %-6d", key, minGap, min, max);
if (color == red) printf("red\n");
else printf("black\n");
}
};

class MGTree
{
private:
static node *nil;//哨兵，静态成员，被整个MGTree类所共有
node *root;
MGTree(const MGTree&);//禁止复制构造
MGTree operator=(const MGTree&);//禁止赋值
void leftRotate(node*);//左旋
void rightRotate(node*);//右旋
void insertFixup(node*);//插入节点后红黑性质调整
void eraseFixup(node*);//删除节点后红黑性质调整
void update(node*);//更新节点信息
void keep(node*);//保持MGTree树的性质，用在insert和erase调用
public:
MGTree() :root(nil)
{
root->parent = nil;
root->left = nil;
root->right = nil;
root->color = black;
root->key = MAX; root->max = MAX;
root->min = MAX; root->minGap = MAX;
}
MGTree(node *rbt) :root(rbt){}//复制构造函数，用于创建子红黑树对象
void insert(int);//插入
void create();//创建红黑树
void erase(int);//删除
node* locate(int)const;//查找
node* minMum()const;//最小值
node* maxMum()const;//最大值
node* successor(int)const;//找后继
node* predecessor(int)const;//前驱
void preTraversal()const;//先根遍历
void inTraversal()const;//中根遍历
void destroy();//销毁红黑树
void minGap()const{ root->print(); }//返回树的最小差幅
bool empty()const{ return root == nil; }//判空
};

node *MGTree::nil = new node;//定义静态成员nil

void MGTree::update(node *curr)
{//更新节点信息
//根据二叉查找树的性质可知无需考虑右子树
curr->min = (curr->left == nil) ? curr->key : curr->left->min;
curr->max = (curr->right == nil) ? curr->key : curr->right->max;
int leftMinGap = (curr->left == nil) ? MAX : curr->left->minGap;
int rightMinGap = (curr->right == nil) ? MAX : curr->right->minGap;
//当前节点与左子树差幅
int currLeftGap = (curr->left == nil) ? MAX : (curr->key - curr->left->max);
int currRightGap = (curr->right == nil) ? MAX : (curr->right->min - curr->key);
curr->minGap = Min4(leftMinGap, rightMinGap, currLeftGap, currRightGap);
}

void MGTree::keep(node *curr)
{
while (curr != nil)
{
update(curr);
curr = curr->parent;
}
}

void MGTree::leftRotate(node *curr)
{
if (curr->right != nil)
{//存在右孩子时才能左旋
node *rchild = curr->right;
curr->right = rchild->left;
if (rchild->left != nil)
rchild->left->parent = curr;
rchild->parent = curr->parent;
if (curr->parent == nil)
root = rchild;
else if (curr == curr->parent->left)
curr->parent->left = rchild;
else curr->parent->right = rchild;
curr->parent = rchild;
rchild->left = curr;
rchild->min = curr->min;
rchild->max = curr->max;
rchild->minGap = curr->minGap;
update(curr);
}
}

void MGTree::rightRotate(node *curr)
{
if (curr->left != nil)
{//存在左孩子时才能右旋
node *lchild = curr->left;
curr->left = lchild->right;
if (lchild->right != nil)
lchild->right->parent = curr;
lchild->parent = curr->parent;
if (curr->parent == nil)
root = lchild;
else if (curr == curr->parent->left)
curr->parent->left = lchild;
else curr->parent->right = lchild;
lchild->right = curr;
curr->parent = lchild;
lchild->min = curr->min;
lchild->max = curr->max;
lchild->minGap = curr->minGap;
update(curr);
}
}

void MGTree::insert(int k)
{
node *pkey = new node(k),
*p = nil, *curr = root;
while (curr != nil)
{//找插入位置
p = curr;//记住当前节点父亲
if (k < curr->key)//往左找
curr = curr->left;
else curr = curr->right;//向右找
}
pkey->parent = p;
if (p == nil)//插入的是第一个节点
root = pkey;
else if (k < p->key)
p->left = pkey;
else p->right = pkey;
pkey->left = pkey->right = nil;
keep(pkey->parent);
insertFixup(pkey);//调整
}

void MGTree::insertFixup(node *curr)
{
while (curr->parent->color == red)
{//父亲为红节点时才需要进入循环调整
if (curr->parent == curr->parent->parent->left)
{//父亲是祖父左孩子
node *uncle = curr->parent->parent->right;
if (uncle != nil && uncle->color == red)
{//情况1，叔叔节点存在且为红色
curr->parent->color = black;
uncle->color = black;
curr->parent->parent->color = red;
curr = curr->parent->parent;
}
else if (curr == curr->parent->right)
{//情况2，叔叔节点为黑色，且当前节点是父亲右孩子
curr = curr->parent;
leftRotate(curr);//将父节点左旋，以转变为情况3
}
else
{//情况3，叔叔节点为黑色，且当前节点是父亲左孩子
curr->parent->color = black;
curr->parent->parent->color = red;
rightRotate(curr->parent->parent);
}
}
else
{//父亲是祖父右孩子，与上面三种情况对称
node *uncle = curr->parent->parent->left;
if (uncle != nil && uncle->color == red)
{//情况1
curr->parent->color = black;
uncle->color = black;
curr->parent->parent->color = red;
curr = curr->parent->parent;
}
else if (curr == curr->parent->left)
{//情况2
curr = curr->parent;
rightRotate(curr);
}
else
{//情况3
curr->parent->color = black;
curr->parent->parent->color = red;
leftRotate(curr->parent->parent);
}
}
}
root->color = black;//跳出循环时将根节点置为黑色
}

void MGTree::create()
{
int k;
cout << "Enter element(s),CTRL+Z to end" << endl;//换行后CTRL+Z结束输入
while (cin >> k)
insert(k);
cin.clear();
}

void MGTree::preTraversal()const
{
node *curr = root;
if (curr != nil)
{
curr->print();
MGTree LEFT(curr->left);//继续左子树先根遍历
LEFT.preTraversal();
MGTree RIGHT(curr->right);
RIGHT.preTraversal();
}
}

void MGTree::inTraversal()const
{
node *curr = root;
if (curr != nil)
{
MGTree LEFT(curr->left);
LEFT.inTraversal();
curr->print();
MGTree RIGHT(curr->right);//继续右子树中根遍历
RIGHT.inTraversal();
}
}

node* MGTree::successor(int k)const
{
node *curr = locate(k);
if (curr->right != nil)
{//若右子树不为空，则后继为右子树最小值
MGTree RIGHT(curr->right);
return RIGHT.minMum();
}
node *p = curr->parent;
while (p != nil && curr == p->right)
{//否则为沿右指针一直向上直到第一个拐弯处节点
curr = p;
p = p->parent;
}
return p;
}

node* MGTree::minMum()const
{
node *curr = root;
while (curr->left != nil)
curr = curr->left;
return curr;
}

node* MGTree::maxMum()const
{
node *curr = root;
while (curr->right != nil)
curr = curr->right;
return curr;
}

node* MGTree::predecessor(int k)const
{
node *curr = locate(k);
if (curr->left != nil)
{//若左子树不为空，则前驱为左子树最大值
MGTree LEFT(curr->left);
return LEFT.maxMum();
}
node *p = curr->parent;
while (p != nil && curr == p->left)
{//否则为沿左指针一直往上的第一个拐弯处节点
curr = p;
p = p->parent;
}
return p;
}

void MGTree::erase(int k)
{
node *curr = locate(k), *pdel, *child;
if (curr == nil)
{
cout << "Error:no data!" << endl;
return;
}
if (curr->left == nil || curr->right == nil)//决定删除节点
pdel = curr;//若当前节点至多有一个孩子，则删除它
else pdel = successor(k);//否则若有两孩子，则删除其后继
node *pdel_parent = pdel->parent;//记下被删节点父母
if (pdel->left != nil)//记下不为空的孩子
child = pdel->left;
else child = pdel->right;
child->parent = pdel_parent;
if (pdel_parent == nil)//若删除的是根节点
root = child;
else if (pdel == pdel_parent->left)//否则若被删节点是其父亲左孩子
pdel_parent->left = child;
else pdel_parent->right = child;
if (curr != pdel)
curr->key = pdel->key;//若被删的是后继，则将后继值赋给当前节点
keep(pdel_parent);//自底向上维护节点信息
if (pdel->color == black)//被删节点为黑色时才调整
eraseFixup(child);
delete pdel;//释放所占内存
}

void MGTree::eraseFixup(node *curr)
{
while (curr != root && curr->color == black)
{//当前不为根，且为黑色
if (curr == curr->parent->left)
{//若其是父亲左孩子
node *brother = curr->parent->right;//兄弟节点肯定存在
if (brother->color == red)
{//情况1，兄弟是红色，转变为情况2,3,4
brother->color = black;
curr->parent->color = red;
leftRotate(curr->parent);
brother = curr->parent->right;
}
if (brother->left->color == black && brother->right->color == black)
{//情况2，兄弟是黑色，且两孩子也是黑色，将当前节点和兄弟去一重黑色
brother->color = red;
curr = curr->parent;
}
else if (brother->right->color == black)
{//情况3，兄弟左孩子为红，右孩子为黑，转变为情况4
brother->color = red;
brother->left->color = black;
rightRotate(brother);
brother = curr->parent->right;
}
else
{//情况4，右孩子为黑色，左孩子随意
brother->color = curr->parent->color;
curr->parent->color = black;
brother->right->color = black;
leftRotate(curr->parent);
curr = root;
}
}
else
{//若其是父亲右孩子，与上面四中情况对称
node *brother = curr->parent->left;
if (brother->color == red)
{//情况1
brother->color = black;
curr->parent->color = red;
rightRotate(curr->parent);
brother = curr->parent->left;
}
if (brother->right->color == black && brother->left->color == black)
{//情况2
brother->color = red;
curr = curr->parent;
}
else if (brother->left->color == black)
{//情况3
brother->color = red;
brother->right->color = black;
leftRotate(brother);
brother = curr->parent->left;
}
else
{//情况4
brother->color = curr->parent->color;
curr->parent->color = black;
brother->left->color = black;
rightRotate(curr->parent);
curr = root;
}
}
}
curr->color = black;//结束循环时将当前节点置为黑色
}

node* MGTree::locate(int k)const
{
node *curr = root;
while (curr != nil && curr->key != k)
{
if (k < curr->key)curr = curr->left;
else curr = curr->right;
}
return curr;
}

void MGTree::destroy()
{
while (root != nil)
{
//cout << "erase: " << root->key << endl;
erase(root->key);
}
delete nil;
}

int main()
{//1 5 9 15 18 22
MGTree mgt;
cout << "create----------" << endl;
mgt.create();
int choice, k;
cout << "Enter your choice,1->insert,2->delete,3->minGap,4->print tree,5->exit" << endl;
do
{
cin >> choice;
switch (choice)
{
case 1:
cout << "Enter a integer: ";
cin >> k;
mgt.insert(k);
break;
case 2:
cout << "Enter a integer: ";
cin >> k;
mgt.erase(k);
break;
case 3:
if (!mgt.empty())mgt.minGap();
else cout << "Error:empty!" << endl;
break;
case 4:
cout << "inTraversal-----" << endl;
mgt.inTraversal();
cout << "preTraversal----" << endl;
mgt.preTraversal();
break;
case 5:
cout << "destroy---------" << endl;
mgt.destroy();
return 0;
default:
cout << "Bad input!" << endl;
}
//cout << "Enter your choice,1->insert,2->delete,3->minGap,4->print tree,5->exit" << endl;
} while (choice >= 1 && choice <= 5);
return 0;
}