算法导论 11.2-4 散列表内未占用槽链接成自由链表

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/mishifangxiangdefeng/article/details/7712094

一、题目

说明在散列表内部,如何通过将所有未占用的槽位链成一个自由表,来分配和去配元素的存储空间。假定一个槽位可以存储一个标志、一个元素加上一个或两个指针。所有的字典操作和自由链表操作应具有O(1)的期望运行时间。该自由链表是双链表吗?或者,是不是单链表就足够了?


二、思考

已知(1)所有未占用的槽位链成一个自由链表(2)槽位即slot(3)Hash(x)返回x所属于的slot

一个slot存储以下内容,占用和未占用时表示的含义不同

struct node
{
	int key;
	bool flag;//0:free,1:used
	int pre;
	int next;
};


当这个slot未占用时,取值如下:

struct node
{
	int key;//没有意义,初始化为-1
	bool flag;//0:free
	int pre;//自由链表中上一个空闲slot,没有则为-1
	int next;//自由链表中下一个空闲slot,没有则为-1
};

当这个slot被占用时,取值如下:

struct node
{
	int key;//关键字
	bool flag;//1:used
	int pre;//具有相同Hash值的下一个结点
	int next;//具有相同Hash值的上一个结点
};

 

插入操作时,从自由链表中取出一个空闲slot,填入关键字x,修改指针,链表相应的队列中,具体可以分为以下几种情况:

(1)x所属的slot未被占用,则

step1:把这个slot从自由链表中移出

step2:填入关键字x

step3:修改指针,在这种情况下其next和pre都置为-1

(2)x所属的slot已经被占用,令占用这个slot的关键是y,y也属于这个slot,则

step1:从自由链表中取出一个空闲的slot,这个slot肯定不是x所属的slot,只是拿过来用

step2:填入关键字x

step3:修改指针,把slot链表入到“以x所属的slot为头结点的队列”中

(3)x所属的slot已经被占用,令占用这个slot的关键是y,y不属于这个slot,通过(2)可知,这个情况是有可能的

step1:从自由链表中取出一个空闲的slot,这个slot肯定不是x所属的slot,也不是y所属的slot,只是拿过来用

step2:在新slot中填入关键字y,修改指针,让y使用这个新slot,而把原来的slot空出来还给x

step3:在x所属的slot中填入关键字x

step4:修改“x所属的slot”指针,类似(1)-step3

 

删除操作时,令待删除的关键字是x,释放x所占用的slot,具体可以分为以下几种情况

(1)x所占用的slot正是x所属的slot,且slot->next=-1,即所有关键字中只有x属于这个slot,x被删除后,slot就空闲了

step1:释放slot到自由链表中

(2)x所占用的slot正是x所属的slot,但还有别的关键字中只有x属于这个slot,应该优先使用关键所属于的slot,而释放“不自己关键字的、临时拿过来用的”slat

step1:从以slot为头结点的队列中另选一个slot2,slot2的关键字属于slot而不属于slot2,只是因为slot被占用,所以才用slot2

step2:把slot2的内容填入slot

step3:修改指针,让slot代替slot2存在于队列中,不同的是slot还是队列头

step4:释放slot2到自由链表中

(3)x所占用的slot不是x所属的slot,这个种情况下,这个slot一定不是队列头,还有别的关键字存在于队列中,并且占用了x所属的slot

step1:把x所占用的slot从“以x所属的slot为头的队列”中移出

step2:释放slot到自由链表中

 

查找操作,如果理解了插入和删除,查找操作就比较简单了,令待查找的关键字是x,也可分为几种情况

(1)x所属的slot未被占用,即不存在与x相同slot的关键字,当然也不存在x了

(2)x所属的slot被占用了,但它所存的关键不属于这个slot,与(1)相同,不存在与x相同slot的关键字

(3)x所属的slot被占用了,且它所存的关键属于这个slot,即存在与x相同slot的关键字,只是不知这个关键字是不是x,需要进一步查找

 

插入和删除过程中反复提到的“从自由链表中取出一个空闲的slot”和“释放slot到自由链表中”这两个操作比较简单,见代码中的解释

 

三、代码

#include <iostream>
#include <string>
using namespace std;
//slot结点
struct node
{
	int key;//关键字
	bool flag;//0:free,1:used
	int pre;
	int next;
};
int Free = 0;//自由链表的头slot
//计算x所属的slot
int Hash(int x)
{
	return x % 20;
}
//从自由链表中取出一个空闲的slot,指定取出的编号为h的slot
int RemoveSlotFromFree(node *A, int h)
{
	//标记为used
	A[h].flag = 1;
	//修改指针移出自由链表
	if(A[h].pre >= 0)
		A[A[h].pre].next = A[h].next;
	else Free = A[h].next;//如果被移出的刚好是表头slot,还要更新表头slot的位置
	if(A[h].next >= 0)
		A[A[h].next].pre = A[h].pre;
	//返回取出的slot的编号
	return h;
}
//将编号为h的slot释放到自由链表中
void FreeSlotToFree(node *A, int h)
{
	//标记为free
	A[h].flag = 0;
	//修改指针,插入到链表头
	A[h].next = Free;
	A[h].pre = -1;
	A[h].key = -1;
	//更新自由链表的头slot
	Free = h;
}
//查找操作
int Search(node *A, int x)
{
	int h = Hash(x);
	//(1)x所属的slot未被占用,即不存在与x相同slot的关键字,当然也不存在x了
	//(2)x所属的slot被占用了,但它所存的关键不属于这个slot,与(1)相同,不存在与x相同slot的关键字
	if(A[h].flag == 0 || Hash(A[h].key) != h)
		return -1;
	//(3)x所属的slot被占用了,且它所存的关键属于这个slot
	//即存在与x相同slot的关键字,只是不知这个关键字是不是x,需要进一步查找
	//查找方法就是遍历以slot为头的队列
	int p = h;
	while(p >=0 && A[p].key != x)
		p = A[p].next;
	if(A[p].key == x)
		return p;
	else return -1;
}
//插入操作时,从自由链表中取出一个空闲slot,填入关键字x,修改指针,链表相应的队列中,
void Insert(node *A, int x)
{
	//是否已经存在
	if(Search(A, x) >= 0)
	{
		cout<<"error:exit"<<endl;
		return ;
	}
	//计算x所属的slot
	int h = Hash(x);
	//(1)x所属的slot未被占用
	if(A[h].flag == 0)
	{
		//step1:把这个slot从自由链表中移出
		int t = RemoveSlotFromFree(A, h);
		//step2:填入关键字x
		A[t].key = x;
		//step3:修改指针,在这种情况下其next和pre都置为-1
		A[t].next = -1;
		A[t].pre = -1;
	}
	//(2)x所属的slot已经被占用,令占用这个slot的关键是y,y也属于这个slot
	else if(Hash(A[h].key) == h)
	{
		//step1:从自由链表中取出一个空闲的slot,这个slot肯定不是x所属的slot,只是拿过来用
		int t = RemoveSlotFromFree(A, Free);
		//step2:填入关键字x
		A[t].key = x;
		//step3:修改指针,把slot链表入到“以x所属的slot为头结点的队列”中
		A[t].next = -1;
		A[h].next = t;
		A[t].pre = h;
	}
	//(3)x所属的slot已经被占用,令占用这个slot的关键是y,y不属于这个slot,
	//通过(2)可知,这个情况是有可能的
	else
	{
		//step1:从自由链表中取出一个空闲的slot,这个slot肯定不是x所属的slot,也不是y所属的slot
		int t = RemoveSlotFromFree(A, Free);
		//step2:在新slot中填入关键字y,修改指针,让y使用这个新slot,而把原来的slot空出来还给x
		A[t] = A[h];
		A[A[h].pre].next = t;
		if(A[h].next >= 0)
			A[A[h].next].pre = t;
		//step3:在x所属的slot中填入关键字x
		A[h].key = x;
		//step4:修改“x所属的slot”指针,类似(1)-step3
		A[h].next = -1;
		A[h].pre = -1;
	}
}
//删除操作时,令待删除的关键字是x,释放x所占用的slot
void Delete(node *A, int x)
{
	//是否存在
	int ret = Search(A, x);
	if(ret < 0)
	{
		cout<<"error:not exit"<<endl;
		return ;
	} 
	//(1)x所占用的slot正是x所属的slot,且slot->next=-1
	//即所有关键字中只有x属于这个slot,x被删除后,slot就空闲了
	if(ret == Hash(x) && A[ret].next == -1)
	{
		FreeSlotToFree(A, ret);
	}
	//(2)x所占用的slot正是x所属的slot,但还有别的关键字中只有x属于这个slot
	//应该优先使用关键所属于的slot,而释放“不自己关键字的、临时拿过来用的”slat
	else if(ret == Hash(x) && A[ret].next != -1)
	{
		//step1:从以slot为头结点的队列中另选一个slot2
		//slot2的关键字属于slot而不属于slot2,只是因为slot被占用,所以才用slot2
		int next = A[ret].next;//next就是slot2的编号
		//step2:把slot2的内容填入slot
		A[ret] = A[A[ret].next];
		//step3:修改指针,让slot代替slot2存在于队列中,不同的是slot还是队列头
		A[A[ret].next].pre = ret;
		//step4:释放slot2到自由链表中
		FreeSlotToFree(A, next);
	}
	//(3)x所占用的slot不是x所属的slot,这个种情况下,这个slot一定不是队列头
	//还有别的关键字存在于队列中,并且占用了x所属的slot
	else if(ret != Hash(x))
	{
		//step1:把x所占用的slot从“以x所属的slot为头的队列”中移出
		A[A[ret].pre].next = A[ret].next;
		if(A[ret].next >= 0)
			A[A[ret].next].pre = A[ret].pre;
		//step2:释放slot到自由链表中
		FreeSlotToFree(A, ret);
	}
}
//输出slot
void Print(node *A)
{
	int i;
	for(i = 0; i < 20; i++)
		cout<<A[i].flag<<' '<<A[i].key<<' '<<A[i].next<<' '<<A[i].pre<<endl;
}
int main()
{
	int i;
	//构造一个拥有20个slot的散列表
	node A[20];
	for(i = 0; i < 20; i++)
	{
		//初始时,所有slot都为free
		A[i].flag = 0;
		if(i == 19)
			A[i].next = -1;
		else A[i].next = i + 1;
		A[i].pre = i - 1;
		A[i].key = -1;
	}
	//test
	string str;
	int x;
	while(1)
	{
		cin>>str;
		if(str == "I")
		{
			x = rand() % 100;
			cout<<x<<endl;
			Insert(A, x);
		}
		else if(str == "D")
		{
			cin>>x;
			Delete(A, x);
		}
		else if(str == "P")
			Print(A);
	}
	return 0;
}


 

 

没有更多推荐了,返回首页

私密
私密原因:
请选择设置私密原因
  • 广告
  • 抄袭
  • 版权
  • 政治
  • 色情
  • 无意义
  • 其他
其他原因:
120
出错啦
系统繁忙,请稍后再试