在查找中，虽然hash表查找非常迅速，但是随着数据的种类增多，
hash表长会变得更长，且冲突也会越来越多，那么如何能实现无论在
多大数据量的情况下，查找依然是高性能的呢？
在1978年,Leo J.Guibas 与 Robert Sedgewick写了一篇论文中
谈到了一种较好的用于查找的数据结构----红黑树
一般来说，树是很好的一种数据结构，那用于插入，删除，查找等
都是很高效的数据树构，但问题是在很坏的情况下，操作很费时间，它的
性能得到不保证，比如二叉查找树中如果左子树与右子树相差太远，那么查找
时就很费时间。这时为了保证其有高效性，就得保证左树与右树不能差得太远，
当向树中插入时，就按一定规则调整，使其达到规则，从而使其整体与局部
查找效率得到提高。这就是红黑树的规则.
这些规则是
在二叉查找树的基础上，
(1)节点都有颜色，要么黑色，要么红色。
(2)根结点是黑色的，叶子结点是黑色的。
(3)每条从树到叶子的路上没有二个连续的红色。即红色的子树一定是黑色
(4)各条从叶子到根的路上的黑色结点相同。
关键的是(3), (4)它使得树是局部是平衡的，并且每条路线不会太长。
还有一个重要的点就是，为了研究方便，会在红黑树补成两个子树是完整的，
它们也有颜色，是黑色，但是没有数据，它称为nil叶子，null叶子。当搜索时
发现结点与nil叶子相 等时，则是找到了叶子了。
另外，关于红黑树与平衡二叉树的区别，它们的区别在概念上也有，
但是在性能上也有，平衡二叉树也是在最坏的情况下有高效的，但是它
追求整体的平衡，使得调整树时，会要很长的时间复杂度，而红黑树是
局部平衡，调整时只要0(logn)颜色变量，并且调整不超过三次。
那么如何使用红黑树来解决问题呢，可以先构造红黑树
构造红黑树的办法如下:
(1)定义节点结构，
一般是 值，key, 长度，左指针，右指针，指向父的指针，颜色。
(2)插入
插入时，先从树根开始，先校验树是不是为空节点或者nil结点，若是
则插入结点为新根，若不是，则与树比较，小于的话，往左移，大于
往右移，这里与二叉查找树类似，最后再对其颜色进行调整.所谓的调
整只有4种情况，都设计好了。
(3)查找
按照二叉查找树的样子进行查找。
例子:查找班上姓名为'xiaoming'同学的基本信息情况
办法: 则要以姓名为关键字建立一个红黑树，建法很多，
可以以其各字母ascii和的办法作为关键字，或以某函数生成一个均可。
然后树据关键字的值生成红黑树，再查找就可以了
部分MFC代码如下:
节点结构。
typedef struct Node
{
Coulor color;
int key;
Node *p,*left,*right;
int size;
char *name; //the description data that the node contained
}Node,*pNode;
下面的代码中，rbInsert(pNode z)为插入创建的函数，
void rbInsertFixUp(pNode z)为调整局部色彩的函数。
－－－－－－－－－－－－－－－－－－
//RBTree.h文件如下
#ifndef RBTREE_H
#define RBTREE_H
#pragma once
#include
#include"MainFrm.h"
enum Coulor{RED,BLACK};
typedef struct Node
{
Coulor color;
int key;
Node *p,*left,*right;
int size;
char *name; //the description data that the node contained
}Node,*pNode;
extern Node Nil; //ÉÚ±ø
extern const pNode nil;
class rbTree
{
public:
pNode root;
pNode cur;
public:
rbTree(){root=cur=&Nil;};
void setName(pNode x,const char*na)
{
x->name=new char[strlen(na)+1];
strcpy(x->name,na);
}
pNode newNode(int k,const char*na="N",pNode pa=nil,pNode le=nil,pNode ri=nil)
{
pNode ne=new Node;
ne->key=k;
ne->color=RED;
ne->left=le;
ne->p=pa;
ne->right=ri;
ne->size=1;
setName(ne,na);
return ne;
}
//·ÃÎÊp,left,rightµÈ
pNode &p(pNode x){return x->p;};
pNode &left(pNode x){return x->left;};
pNode &right(pNode x){return x->right;};
int &size(pNode x){return x->size;};
Coulor &color(pNode x){return x->color;};
int &key(pNode x){return x->key;};
//
const pNode P(pNode x){return x->p;};
const pNode Left(pNode x){return x->left;};
const pNode Right(pNode x){return x->right;};
const int Size(pNode x){return x->size;};
const Coulor Color(pNode x){return x->color;};
const int Key(pNode x){return x->key;};
pNode successor(pNode x)
{
if(Right(x) != nil)
return minimum(Right(x));
pNode y= P(x);
while ( y!=nil && x==Right(y) )
{
x=y;
y=P(y);
}
return y;
}
//
pNode minimum( pNode x)
{
while (Left(x)!=nil)
x=Left(x);
return x;
}
int Bheight(pNode x)
{
pNode y=x;
int k=0;
while(y!=nil)
{
if(Color(y)==BLACK)
k++;
y=Left(y);
}
return k;
}
//×óÐýת
void lrotate(pNode x)
{
pNode y=Right(x);
//ά»¤size;
int sx=x->size;
int sy=y->size;
size(y)=sx;
size(x)=sx-size(Right(y))-1;
right(x)=Left(y);
p(Left(y))=x;
p(y)=P(x);
if(P(x)==nil)
{
root=y;
}
else if( x == Left(P(x)) )
{
left(P(y))=y;
}
else
right(P(x))=y;
left(y)=x;
p(x)=y;
}
//ÓÒÐýת
void rrotate(pNode x)
{
pNode y=Left(x);
//ά»¤size;
size(y)=Size(x);
size(x)=Size(x)-Size(Left(y))-1;
left(x)=Right(y);
p(Right(y))=x;
p(y)=P(x);
if(P(x)==nil)
{
root=y;
}
else if(x==Left(P(x)))
{
left(P(y))=y;
}
else
right(P(x))=y;
right(y)=x;
p(x)=y;
}
///
//²åÈë¼°Æäµ÷Õû
//²åÈë
void rbInsert(pNode z)
{
pNode y=nil;
pNode x=root;
while(x!=nil)
{
y=x;
size(x)=Size(x)+1;
if(Key(z) < Key(x))
x=Left(x);
else
x=Right(x);
}
p(z)=y;
if(y == nil)
root=z;
else if(Key(z)
left(y)=z;
else
right(y)=z;
rbInsertFixUp(z);
}
//µ÷Õû
void rbInsertFixUp(pNode z)
{
while(Color(P(z)) == RED)
{
if( P(z) == Left(P(P(z))))
{
pNode y=Right(P(P(z)));
if(Color(y) == RED)
{
color(P(z)) = BLACK;
color(y)= BLACK;
color(P(P(z))) =RED;
z=P(P(z));
}
else
{
if(z == Right(P(z)))
{
z=P(z);
lrotate(z);
}
color(P(z))=BLACK;
color(P(P(z)))=RED;
rrotate(p(P(z)));
}
}
else
{
pNode y=Left(P(P(z)));
if(Color(y) == RED)
{
color(P(z)) = BLACK;
color(y)= BLACK;
color(P(P(z))) =RED;
z=P(P(z));
}
else
{
if(z == Left(P(z)))
{
z=P(z);
rrotate(z);
}
color(P(z))=BLACK;
color(P(P(z)))=RED;
lrotate(p(P(z)));
}
}
}
color(root)=BLACK;
}
//
//ɾ³ý¼°Æäµ÷Õû
//ɾ³ý
pNode rbDelete(pNode z)
{
pNode x,y;
if(Left(z) == nil ||Right(z)==nil)
y=z;
else
y=successor(z);
if(Left(y) !=nil)
x=Left(y);
else
x=Right(y);
p(x)=P(y);
if(P(y) ==nil)
root=x;
else if(y==Left(P(y)) )
left(P(y))=x;
else
right(P(y))=x;
if(y!=z)
{
key(z)=Key(y);//
}
rbDeleteMaitainSize(y);
if(Color(y)==BLACK)
rbDeleteFixUp(x);
return y;
}
//µ÷Õû
void rbDeleteFixUp(pNode x)
{
while(x!=root && Color(x)==BLACK)
{
if(x ==Left(P(x)) )
{
pNode w=Right(P(x));
//case1
if(Color(w)==RED)
{
color(w)=BLACK;
color(P(x))=RED;
lrotate(P(x));
w=Right(P(x));
}
//case 2,3,4
if(Color(Left(w))==BLACK && Color(Right(w)) ==BLACK)
{
color(w)=RED;
x=P(x);
}
else if(Color(Right(w)) == BLACK)
{
color(Left(w))=BLACK;
color(w)=RED;
rrotate(w);
w=Right(P(x));
}
else
{
color(w)=Color(P(x));
color(P(x))=BLACK;
lrotate(P(x));
x=root;
}
}
else
{
pNode w=Left(P(x));
//case1
if(Color(w)==RED)
{
color(P(x))=RED;
rrotate(P(x));
w=Left(P(x));
}
//case 2,3,4
if(Color(Left(w))==BLACK && Color(Right(w)) ==BLACK)
{
color(w)=RED;
x=P(x);
}
else if(Color(Left(w)) == BLACK)
{
color(Right(w))=BLACK;
color(w)=RED;
lrotate(w);
w=Left(P(x));
}
else
{
color(w)=Color(P(x));
color(P(x))=BLACK;
rrotate(P(x));
x=root;
}
}
}
color(x)=BLACK;
}
/
//ά»¤size
void rbDeleteMaitainSize(pNode x)
{
cur=P(x);
while(cur!=nil)
{
size(cur)--;
cur=P(cur);
}
}
int Rank(pNode x)
{
int r= Size(Left(x))+1;
pNode y=x;
while(y!=root)
{
if( y == Right( P(y) ) )
{
r=r+Size(Left( P(y) ) )+1;
}
y=P(y);
}
return r;
}
pNode OS_Select(pNode x,int i)
{
if(i>Size(x))
return nil;
int r=Size(Left(x))+1;
if(i==r)
return x;
else if(i
return OS_Select(Left(x),i);
else
return OS_Select(Right(x),i-r);
}
friend class CMyWnd;//ÏÔʾºìºÚÊ÷µÄͼÐνçÃæÀࣻ
};
#endif
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
