动态集合中两个最接近的数的差值

题目：

思考：

既然是动态集合，那么我们需要用链表来存储数据方便插入和删除。于是我们可以选用二叉链表，也就是红黑树来存储数据，红黑树由于比较平衡，所以可以得到比较好的查询时间。但是我们并不是直接拿红黑树就可以用了，因为基本的红黑树没有MIN_GAP操作，所以需要自己修改和维护原始的红黑树。

如何给红黑树添加MIN_GAP操作呢？我们需要先给红黑树结构中加入MAX，MIN指针。这个操作可以参考最坏时间为O(1)的求最大小值，当然只取了里面部分新增代码。既然新指针已经添加好了，那么我们以原有红黑树插入删除操作为子程序，添加针对本题的新插入删除操作。新的插入删除函数维护2个树，一棵是集合Q所组成的树，还有一棵是Q的每两个最接近数的差值组成的树T2

如何添加新的插入删除操作呢？分以下几个步骤来讲：

插入操作：①先将新结点z插入树中。

②找到新结点z的前驱x1和后继x2。

③分别找到新结点与前驱和后继的GAP，分别插入到以Q的两个最接近数为差值组成的树T2中。

④最后将x1与x2的GAP删除。

删除操作：①查找值为z的结点x。

②找到待删除结点z的前驱x1和后继x2。

③分别找到待删除结点与前驱和后继的GAP，分别删除。

④在删除z之前，z的前驱和后继在删除z后会形成新的GAP，所以插入这个GAP。

⑤最后删除z.

代码如下:

#include <iostream>
#include <time.h>
using namespace std;
#define BLACK 0
#define RED 1
#define Nil -1
#define LEN sizeof(struct Tree)
#define n 10//这里更改数据量
struct Tree
{
   struct Tree*left;
   struct Tree*right;
   struct Tree*parent;
   int key;
   int color;
   struct Tree*Min;//记录以x为根结点的树中最小的关键字
   struct Tree* Max;//记录以x为根结点的树中最大的关键字 

};
struct Tree*root1=NULL;
struct Tree*root2=NULL;
struct Tree*nil=NULL;
//非递归版本的查找二叉查找树的最小值
struct Tree*ITERATIVE_TREE_MINIMUM(struct Tree*x)
{
	while (x!=nil&&x->left!=nil)
	{
		x=x->left;
	}
	return x;
}
//非递归版本的查找二叉查找树的最大值
struct Tree*ITERATIVE_TREE_MAXIMUM(struct Tree*x)
{
	while (x!=nil&&x->right!=nil)
	{
		x=x->right;
	}
	return x;
}
void LEFT_ROTATE(struct Tree*&root,struct Tree*x)
{//左旋转：分三个步骤①②③来叙述旋转代码的。
	struct Tree*y=x->right;//设置y结点。
	if(y->left!=nil)x->Max=y->left->Max;//对附加信息的维护
	else x->Max=x;
	y->Min=x->Min;
	x->right=y->left;//本行代码以及下面的if结构表达的是“y的左孩子成为x的右孩子”。①
	if(y->left!=nil)
	{
       y->left->parent=x;
	}
	y->parent=x->parent;//本行代码以及下面的if-else结构表达的过程是“y成为该子树新的根”。②
	if(x->parent==nil)
	{
       root=y;
	}
	else if(x==x->parent->left)
	{
       x->parent->left=y;
	}
	else x->parent->right=y;
	y->left=x;//本行代码以及下面一行都表达了“x成为y的左孩子”。③
	x->parent=y;
}
void RIGHT_ROTATE(struct Tree*&root,struct Tree*x)
{//右旋转：分三个步骤①②③来叙述旋转代码的。
	struct Tree*y=x->left;//设置y结点。
	if(y->right!=nil) x->Min=y->right->Min;//对附加信息的维护
	else x->Min=x;
	y->Max=x->Max;
	x->left=y->right;//本行代码以及下面的if结构表达的是“y的左孩子成为x的右孩子”。①
	if(y->right!=nil)
	{
		y->right->parent=x;
	}
	y->parent=x->parent;//本行代码以及下面的if-else结构表达的过程是“y成为该子树新的根”。②
	if(x->parent==nil)
	{
		root=y;
	}
	else if(x==x->parent->right)
	{
		x->parent->right=y;
	}
	else x->parent->left=y;
	y->right=x;//本行代码以及下面一行都表达了“x成为y的左孩子”。③
	x->parent=y;
}
void RB_INSERT_FIXUP(struct Tree*&root,struct Tree*z)
{
   while (z->parent->color==RED)
   {
	   if (z->parent==z->parent->parent->left)
	   {
		   struct Tree*y=z->parent->parent->right;//叔结点
		   if (y->color==RED)//情况一：叔结点为红色
		   {//给p1,y,p2着色以保持性质5。并且解决了z的父结点和z都是红色结点问题
			   z->parent->color=BLACK;
			   y->color=BLACK;
			   z->parent->parent->color=RED;
			   z=z->parent->parent;//把z的祖父结点当成新结点z进入下一次循环
		   }
		   else
		   {
			   if (z==z->parent->right)//情况二：检查z是否是一个右孩子且叔结点为黑色，前提是p1结点不是叶子结点
			   {//使用一个左旋让情况2转变为情况3
				   z=z->parent;
				   LEFT_ROTATE(root,z);//由于进入if语句后可知旋转结点不可能是叶子结点，这样就不用判断z是否是叶子结点了。
			   }
               z->parent->color=BLACK;//情况三：是z是一个左孩子且叔结点为黑色，改变z的父和祖父结点颜色并做一次右旋，以保持性质5
			   z->parent->parent->color=RED;
			   RIGHT_ROTATE(root,z->parent->parent);//由于p2可能是叶子结点，所以最好还是用一个if判断
		   }
	   }
	   else//下面else分支类似于上面,注意到else分支的情况2和情况3所做旋转正好是if分支情况的逆。
	   {
		   struct Tree*y=z->parent->parent->left;
		   if (y->color==RED)
		   {
			   z->parent->color=BLACK;
			   y->color=BLACK;
			   z->parent->parent->color=RED;
			   z=z->parent->parent;
		   }
		   else
		   {
			   if (z==z->parent->left)
			   {
				   z=z->parent;
				   RIGHT_ROTATE(root,z);
			   }
               z->parent->color=BLACK;
			   z->parent->parent->color=RED;
			   LEFT_ROTATE(root,z->parent->parent);
		   }
	   }
   }
   root->color=BLACK;//最后给根结点着为黑色。
}
void RB_INSERT(struct Tree*&root,struct Tree*z)
{
	struct Tree*y=nil;
	struct Tree*x=root;
	while (x!=nil)
	{
		y=x;
		if (z->key<x->key)
		{
			x=x->left;
		}
		else x=x->right;
	}
	z->parent=y;
	if (y==nil)
	{
		root=z;
	}
	else if(z->key<y->key)
	{
		y->left=z;
		while (y)
		{
			y->Min=z;
			if (y->parent==nil||y->parent->right==y)
			{
				break;
			}
			y=y->parent;
		}
	}
	else
	{
		y->right=z;
		while (y)
		{
			y->Max=z;
			if (y->parent==nil||y->parent->left==y)
			{
				break;
			}
			y=y->parent;
		}
	}
	z->left=nil;//给插入结点左右孩子赋值为空。
	z->right=nil;
	z->color=RED;//给插入结点着为红色。
	z->Max=z->Min=z;
	RB_INSERT_FIXUP(root,z);
}
void RB_TRANSPLANT(struct Tree*&root,struct Tree*u,struct Tree*v)
{
	if (u->parent==nil)
		root=v;
	else if(u==u->parent->left)
		u->parent->left=v;
	else u->parent->right=v;
	v->parent=u->parent;
}
//查找二叉查找树的前驱
struct Tree*TREE_PREDECESSOR(struct Tree*x)
{
   if (x->left!=nil)
   {
	   return ITERATIVE_TREE_MAXIMUM(x->left);
   }
   struct Tree*y=x->parent;
   while (y!=nil&&x==y->left)
   {
	   x=y;
	   y=y->parent;
   }
   return y;
}
//查找二叉查找树的后继
struct Tree*TREE_SUCCESSOR(struct Tree*x)
{
	if (x->right!=nil)
	{
		return ITERATIVE_TREE_MINIMUM(x->right);
	}
	struct Tree*y=x->parent;
	while (y!=nil&&x==y->right)
	{
		x=y;
		y=y->parent;
	}
	return y;
}
//非递归版本的二叉查找树查找函数
struct Tree*ITERATIVE_TREE_SEARCH(struct Tree*x,int k)
{
	while (x!=nil&&k!=x->key)
	{
		if (k<x->key)
		{
			x=x->left;
		}
		else x=x->right;
	}
	return x;
}
void RB_DELETE_FIXUP(struct Tree*&root,struct Tree*x)
{
	 struct Tree*w=NULL;//w是x的兄弟结点
     while (x!=root&&x->color==BLACK)//如果x是黑色并且不是根结点，才进行循环。
     {//x是一个具有双重颜色的结点，调整的目的是把x的黑色属性向上移动。
		 if (x==x->parent->left)
		 {
			 w=x->parent->right;
			 if (w->color==RED)//情况一：x的兄弟结点w是红色的。
			 {//改变w和x.p的颜色+一次旋转使其变为情况二，三，四。
				 w->color=BLACK;
				 x->parent->color=RED;
				 LEFT_ROTATE(root,x->parent);
				 w=x->parent->right;
			 }
			 if (w->left->color==BLACK&&w->right->color==BLACK)//情况二：x的兄弟结点w是黑色的，而且w的两个子节点都是黑色。
			 {
				 w->color=RED;//从x和w上去掉一重黑色。x还是黑色，而w变为红色。
				 x=x->parent;//x结点向上移动成为新的待调整结点。
			 }
			 else
			 {
				 if (w->right->color==BLACK)//情况三：x的兄弟结点w是黑色的，w的左孩子是红色的，w的右孩子是黑色的。
				 {//交换w和w.left的颜色+旋转使其转变为情况四。
					 w->left->color=BLACK;
					 w->color=RED;
					 RIGHT_ROTATE(root,w);
					 w=x->parent->right;
				 }
				 w->color=x->parent->color;//以下是情况四：x的兄弟结点w是黑色的，且w的右孩子是红色的。
				 x->parent->color=BLACK;//置x.p和w.right为黑色+旋转使其去掉x的额外黑色。
				 w->right->color=BLACK;
				 LEFT_ROTATE(root,x->parent);
				 x=root;//x成为根结点，结束循环。
			 }
		 }
		 else//以下和上面的if分支类似，不做累述。
		 {
             w=x->parent->left;
			 if (w->color==RED)
			 {
				 w->color=BLACK;
				 x->parent->color=RED;
				 RIGHT_ROTATE(root,x->parent);
				 w=x->parent->left;
			 }
			 if (w->left->color==BLACK&&w->right->color==BLACK)
			 {
				 w->color=RED;
				 x=x->parent;
			 }
			 else
			 {
				 if (w->left->color==BLACK)
				 {
					 w->right->color=BLACK;
					 w->color=RED;
					 LEFT_ROTATE(root,w);
					 w=x->parent->left;
				 }
				 w->color=x->parent->color;
				 x->parent->color=BLACK;
				 w->left->color=BLACK;
				 RIGHT_ROTATE(root,x->parent);
				 x=root;
			 }
		 }
     }
	 x->color=BLACK;
}
void RB_DELETE(struct Tree*&root,struct Tree*z)
{
    struct Tree*y=z,*x;//y为待删除或待移动结点
	int y_original_color=y->color;//保存y的原始颜色，为做最后的调整做准备。
	struct Tree*k=z->parent,*p=z->parent,*t=z->parent;
	if (z->left==nil)
	{
		x=z->right;//x指向y的唯一子结点或者是叶子结点，保存x的踪迹使其移动到y的原始位置上
		if (z->parent->left==z)
		{
			if (x!=nil)
			{
				while (p!=nil&&p->parent->left==p)
				{
					p->Min=x->Min;
					p=p->parent;
				}
				p->Min=x->Min;
			}
			else
			{
				while (p!=nil&&p->parent->left==p)
				{
					p->Min=k;
					p=p->parent;
				}
				p->Min=k;
			}
		}
		else
		{
			if (x!=nil)
			{
				while(p!=nil&&p->parent->right==p)
				{
                    p->Max=x->Max;
					p=p->parent;
				}
                p->Max=x->Max;
			}
			else
			{
				while (p!=nil&&p->parent->right==p)
				{
					p->Max=k;
					p=p->parent;
				}
				p->Max=k;
			}
		}
		RB_TRANSPLANT(root,z,z->right);//把以z.right为根的子树替换以z为根的子树。
	}
	else if (z->right==nil)
	{
		x=z->left;//x指向y的唯一子结点或者是叶子结点，保存x的踪迹使其移动到y的原始位置上
		if(z->parent->right==z)
		{
			while (p!=nil&&p->parent->right==p)
			{
				p->Max=x->Max;
				p=p->parent;
			}
            p->Max=x->Max;
		}
		else
		{
			while (p!=nil&&p->parent->left==p)
			{
				p->Min=x->Min;
				p=p->parent;
			}
			p->Min=x->Min;
		}
		RB_TRANSPLANT(root,z,z->left);//把以z.left为根的子树替换以z为根的子树。
	}
	else
	{
		y=ITERATIVE_TREE_MINIMUM(z->right);//找到z.right的后继。
        y_original_color=y->color;//y的新的原始结点被重置。
		x=y->right;//x指向y的唯一子结点或者是叶子结点，保存x的踪迹使其移动到y的原始位置上
		y->Min=z->left->Min;
		if (y->parent==z)
		{
			x->parent=y;//由于z的父结点是要删除的结点，所以不能指向它，于是指向y
		}
		else
		{
			struct Tree*w=z->right;
			if (y->right!=nil)
			{
				while (w->left!=nil)
				{
					w->Min=x->Min;
					w=w->left;
				}
			}
			else
			{
				while (w->left!=nil)
				{
					w->Min=y->parent;
					w=w->left;
				}
			}
			y->Max=z->Max;//+
			RB_TRANSPLANT(root,y,y->right);//把以y.right为根的子树替换以y为根的子树。
			y->right=z->right;
			y->right->parent=y;
		}
		RB_TRANSPLANT(root,z,y);//把以y为根的子树替换以z为根的子树。
		y->left=z->left;
		y->left->parent=y;
		y->color=z->color;//把已经删除的结点颜色赋值给y，保证了y以上的树结构红黑性质不变。
	}
	if(y_original_color==BLACK) //y的原始颜色为黑色，说明需要调整红黑颜色。
		RB_DELETE_FIXUP(root,x);
	if (root==nil)
	{
		root->Max=root->Min=nil;
	}
}
//中序遍历
void InOderTraverse(struct Tree *p)
{
    if (p!=nil)
	{
		InOderTraverse(p->left);
		cout<<p->key<<" ";
		InOderTraverse(p->right);
	}
}
//我们以原有红黑树各种操作作为子函数来创建新的插入删除函数
//新的插入删除函数维护2个树，一棵是集合Q所组成的树，还有一棵是Q的每两个最接近数的差值组成的树
void INSERT_GAP(struct Tree *&r1,struct Tree *&r2,struct Tree *z)
{//O(lgn)
	RB_INSERT(r1,z);//先将新结点插入树中。
	struct Tree *x1=TREE_PREDECESSOR(z);//找到x1为前驱
	struct Tree *x2=TREE_SUCCESSOR(z);//找到x2为后继
	if (x1!=nil)
	{
	   struct Tree*x=new struct Tree[LEN];
	   x->key=z->key-x1->key;
	   RB_INSERT(r2,x);//插入z与z的前驱的GAP
	}
	if (x2!=nil)
	{
		struct Tree*x=new struct Tree[LEN];
		x->key=x2->key-z->key;
	   RB_INSERT(r2,x);//插入z的后继与z的GAP
	}
	if (x1!=nil&&x2!=nil)
	{
        struct Tree *x=ITERATIVE_TREE_SEARCH(r2,x2->key-x1->key);
        if(x!=nil) RB_DELETE(r2,x);//删除原x1与x2的GAP
	}
}
void DELETE_GAP(struct Tree *&r1,struct Tree *&r2,int z)
{
   struct Tree*x=ITERATIVE_TREE_SEARCH(r1,z);//查找值为z的结点x
   struct Tree *x1=TREE_PREDECESSOR(x);//x1为x的前驱
   struct Tree *x2=TREE_SUCCESSOR(x);//x2为x的后继
   if(x1!=nil)
   {
     struct Tree* y1=ITERATIVE_TREE_SEARCH(r2,z-x1->key);
	  RB_DELETE(r2,y1);//找到z与z的前驱的GAP并删除它
   }
   if(x2!=nil)
   {
      struct Tree*y2=ITERATIVE_TREE_SEARCH(r2,x2->key-z);
	  RB_DELETE(r2,y2);//找到z与z的后继的GAP并删除它
   }
   if (x1!=nil&&x2!=nil)
   {
	   struct Tree*d=new struct Tree[LEN];
	   d->key=x2->key-x1->key;
	   RB_INSERT(r2,d);//z被删除后，z的前驱后继会形成新的GAP插入它
   }
   RB_DELETE(r1,x);//最后将z删除。
}
struct Tree*MIN_GAP(struct Tree*r2)
{
	return r2->Min;
}
void main()
{
	srand( (unsigned)time( NULL ) );
	int array1[n] ={0};
	for (int j=0;j<n;j++)
	{
		array1[j]=rand()%100+1;
	}
	nil=new struct Tree[LEN];
	nil->key=Nil;nil->color=BLACK;
	root2=root1=nil;
	int i=0;
	struct Tree*ROOT=new struct Tree[LEN];
	ROOT->key=array1[i++];
	INSERT_GAP(root1,root2,ROOT);
	root1=ROOT;
    while (i!=n)
    {
		struct Tree*z=new struct Tree[LEN];
		z->key=array1[i];
		INSERT_GAP(root1,root2,z);
		i++;
    }
	InOderTraverse(root1);
	cout<<endl;
	InOderTraverse(root2);
	cout<<endl;
	cout<<"插入后，GAP="<<MIN_GAP(root2)->key<<endl;
	cout<<endl;
	for(i = 0; i< n; i++)
	{
		DELETE_GAP(root1,root2,array1[i]);
		cout<<"删除"<<array1[i]<<"后，动态集合Q：GAP="<<MIN_GAP(root2)->key<<endl;
		InOderTraverse(root1);
		cout<<endl;
		cout<<"由动态集合Q每两个最接近数据组成的GAP组成的集合为:"<<endl;
		InOderTraverse(root2);
		cout<<endl;
		cout<<endl;
	}
}

总结：总体上来说MIN_GAP运行时间为O(1),而插入删除前驱后继以及查询操作均为O(lgn)，注意这里新增的插入删除操作无非涉及到了原红黑树插入删除查询前驱后继这5种操作，每个操作都是O(lgn),所以新插入删除操作时间为O(lgn).不对红黑树渐近性能产生任何影响。再说新添加的最大小指针，在原有的红黑树各种操作中也没有影响，比如旋转只增加了常数时间，而插入删除只是增加了从根到叶子这条O(lgn)路径的更新最值操作，所以也没有影响渐近性能。可能略微影响O(lgn)中的常系数。最后还有一点，由于需要维护两棵树，那么就增加了存储空间，但是由于增加了树T2，我们可以很容易遍历原数据的所有GAP，而不光仅是最小GAP。





动态集合中两个最接近的数的差值