一、选择题

1.D 2.B 3.A B 4.C 5.B 6.C 7.B 8.D 9.D 10.C

二、填空题

  1. 1 7
  2. 8 59/15
  3. 3.4
  4. 冲突
  5. 949
  6. 小于等于表长的最大素数
  7. 9 3
  8. 拉链法
  9. a[9]
  10. 2

三、判断题

1.× 2. × 3. × 4. × 5. × 6. √ 7. × 8. × 9. √ 10. √
7. 哈希表的结点中可以包含指针,指向其元素
8. 也可以链式存储

四、简答题

  1. 答案如下:
  2. 二叉排序树如下:
  3. 散列表如下:
  4. 答案如下:
  5. 答案如下:

五、计算题

  1. 【思想】采用循环语句边查找边累计层次n(初始时bt指向根结点,n=1)。当找到关键字为k的结点时返回n;否则返回0,算法如下:
int level(BSTNode *bt,KeyType k)
{
	int n=1;
	BSTNode *p=bt;
	while(p && p->key !=k)
	{
		if(k<p->key)
			p=p->lchild;
		else
			p=p->rchild;
		n++;
	}
	if(p)
		return n;
	return 0;
}
  1. 【思想】对于二叉排序树俩说,其中序遍历序列为一个递增有序序列。因此,对给定的二叉树进行中序遍历,如果始终能保持前一个值比后一个小,则说明该二叉树是一棵二叉排序树。算法如下:
KeyType predt=-32767;
int JudgeBST(BSTNode *bt)
{
	int b1,b2;
	if(NULL==bt)
		return 1;
	else
	{
		b1=JudgeBST(bt->lchild);
		if(0==b1 || predt>=bt->key)
			return 0;
		predt=bt->key;
		b2=JudgeBST(bt->rchild);
		return b2;
	}
}
  1. 【思想】在哈希表中删除关键字为k的记录的过程:先调用SearchHT(ha,p,k)找到关键字k在哈希表中的地址addr,若addr=-1,表示哈希表中不存在这样的关键字,返回0;否则在ha[adr]为头结点的单链表中查找并删除关键字为k的节点,返回1.对应算法如下
int DeleteHT(HNode *ha[],int p,int k)
{
	int adr;
	HNode *q;
	SNode *s,*t;
	adr=SearchHT(ha,p,k);
	if(adr!=-1)
	{
		q=ha[adr];
		s=q->next;
		if(s->key==k)
		{
			q->next=s->next;
			free(s);
		}
		else
		{
			t=s;s=s->next; //t指向*s的前一个结点
			while(s &&s->key!=k)
			{
				t=s;
				s=s->next;
			}
			t->next=s->next;
			free(s);
		}
		return 1;
	}
	else
		retrun 0;
}

4.哈希表: ha[0…m-1] 存放元素n个, 哈希函数 H(key)=key%p(p<=m), 平方探测法: H=(H(key)+d)%m d= 1,-1,4,-4…
【思想】建立哈希表的过程:先将表中各节点的关键字清空,使其地址为开放的,然后调用插入算法将给定的关键字依次插入表中,代码如下:

//将k插入到哈希表
void InsertHT(HastTable ha,int &n,KeyType k,int p,int m)
{
	int i,j,adr,adr1,sign;
	adr=adr1=k%p;
	if(ha[adr].key==NULLKEY || ha[adr].key==DELKEY)
	{
		ha[adr].key=k;
		ha[adr].count=1;
	}
	else
	{
		sign=1;
		i=j=1;
		do{
			adr=(adr1+sign*i*i)%m;
			if(sign==1)
				sign=-1;
			else
			{
				sign=1;
				i++;
			}
			j++;
		}while(ha[adr].key!=NULLKEY &&ha[adr].key!=DELKEY)
		ha[adr].key=k;
		ha[adr].count=j;
	}
	n++;
}
//创建哈希表
void CreatHT(HashTable ha,KeyType x[],int n,int m,int p)
{
	int i,n1=0;
	//哈希表置初值
	for(i=0;i<m;i++)
	{
		ha[i].key=NULLKEY;
		ha[i].count=0;
	}
	for(i=0;i<n;i++)
		InsertHT(ha,n1,x[i],p,m);
}
  1. 哈希表: ha[0…m-1] 存放元素n个, 哈希函数 H(key)=key%p(p<=m),
    解决冲突方法:拉链法
    【思想】建立哈希表的过程:先创建表头结点并将next置空,然后调用插入算法将给定的关键字序列依次插入到哈希表中。对应算法如下:
//将k插入到哈希表
void InsertHT(HNode * ha[],KeyType k,int p)
{
	int adr;
	HNode *q;
	SNode *s,*t;
	adr=k%p;
	s=(SNode*)malloc(sizeof(SNode));
	s->key=k;
	s->next=NULL;
	q=ha[adr];
	t=q->next;
	if(NULL==t)
		q->next=s;
	else
	{
		while(t->next!=NULL)
			t=t->next;
		t->next=s;
	}
}
//创建哈希表
void CreatHT(HNode * ha[],KeyType x[],int n,int p)
{
	int i=0;
	//哈希表置空
	for(i=0;i<p;i++)
	{
		ha[i]=(HNode*)malloc(sizeof(HNOde));
		ha[i]->next=NULL;
	}
	for(i=0;i<n;i++)
		InsertHT(ha,x[i],p);
}
  1. 【思想】在哈希表中查找关键字k的过程:根据建表时设定的哈希函数H,计算出关键字k对应的哈希地址adr,若在ha[adr]为头结点的单链表中存在关键字为k的节点,返回adr;否则返回-1。对应算法如下:
int SearchHT(HNode *ha[],int p,KeyType k)
{
	int adr;
	SNode *q;
	adr=k%p;
	q=ha[adr]->next;
	while(q && q->key!=k)
		q=q->next;
	if(NULL==q)
		return -1;
	else
		return adr;
}

六、说明

本人已毕业多年,读研时撰写了一份 《数据结构与算法分析(C++语言版)_张琨版 课后习题答案》,每年依旧有大量考研的学弟学妹们来找这份答案,现将其公布在blog上,仅供学术交流,上述解答如有问题,可私信沟通。