2016年暨南大学数据结构考研试题答案

return 0;
}
void mergeTreeNode(Tree* T, int &length, int i, int j){//合并树的节点
if(length <= 1)
return;
//生成合并后的节点
Tree temp;
temp = (Tree)malloc(sizeof(TreeNode));
1. 算法思想：基于快速排序
//假设关键字都是存储在 a[]数组中
void division(int a[],int n,int key){
int low=0，high=n-1;
int p=a[low]
while(low<=high){
while(low<high&&a[high]>=key])
high--;
8. (1,4,2,3)
三、
判断题
1. X
【解答】在 n 个结点的无向图中,若该图是连通图,则其边数大于等于 n-1,
在 n 个结点的无向图中,若边数大于(n-2)(n-1)/2,则该图必是连通图。
2. √
3. X
4. √
5. X
【解答】数据元素是数据的基本单位
6. X
【解答】Prim 算法适用于求解边稠密的图的最小生成树
temp->weight = T[i]->weight + T[j]->weight;
temp->lchild = T[i];
temp->rchild = T[j];
//在节点数组中删除原节点 i
for(int k = i; k < length-1; k++){
T[k] = T[k+1];
}
length--;
typedef struct BinTreeNode{
int weight;
BinTreeNode *lchild;
BinTreeNode *rchild;
}TreeNode,*Tree;
void mergeTreeNode(Tree* T, int &length, int i, int j);//合并树的节点
int min,second_min;
min = 0;
for(int k = 0; k < length; k++){
if(T[k]->weight < T[min]->weight){
min = k;
}
}
if(min == 0){
second_min = 1;
}else{
second_min = 0;
}
void traverse(Tree T,int deepth,int &ans){//递归遍历二叉树，累加计算带权路径长度
if(T == NULL) return;
if(T->lchild == NULL && T->rchild == NULL){
ans += T->weight*deepth;
7. X
8. √
9. √
10. X
四、
简答题
1. （1）画出二叉树如下：
（2）将该数转换为森林得：
2. 画出散列之后的 hash 表得：
0
1
48
71
2
3
4
5
6
7
8
9
23
73
14
55
33
43
89
成功查找的平均查找长度为：（1+1+2+2+2+1+5+6+3）/7=23/7
3. 平衡二叉树构造过程如下：
//在节点数组中删除原节点 j
for(int k = j-1; k < length-1; k++){
T[k] = T[k+1];
}
length--;
//将合并后的节点存储起来
T[length++] = temp;
}
void findMin(Tree* T,int &length, int &i, int &j){//寻找权值最小的两个节点
Tree t[n];
int length = n;
for(int i = 0; i < n; i++){
t[i] = (Tree)malloc(sizeof(TreeNode));
cin >> t[i]->weight;
t[i]->lchild = NULL;
t[i]->rchild = NULL;
}
traverse(T->lchild,deepth+1,ans);
traverse(T->rchild,deepth+1,ans);
}
（2）在求得 Huffman 树的情况下，我们可以采用中序遍历非递归，当遇到叶子结点的时候，我们遍
历栈中的内容，即为该叶子结点的 Huffman 编码。
void findMin(Tree* T,int &length, int &i, int &j);//寻找权值最小的两个节点
void traverse(Tree T,int deepth,int &ans);//递归遍历二叉树，累加计算带权路径长度
int main(void){
int n;
cin >> n;
一、
选择题
1. B
【解答】线索二叉树的构成
2. B
3. A
4. C
5. A
6. 1200
【解答】因为是按照行优先次序存储，根据规则，可得：
A[5,5]的地址为：1000+[5*(6+1)+5]*5=1200
7. A
【解答】结点数最小的情况是：前 n-1 层都是满的，第 n 层就一个节点
8. B
9. C
五、
算法填空
1. （1）p->next=L->next
（2）L->next=p
2.
ຫໍສະໝຸດ Baidu
（3）T->lchild
（4）p=p->lchild
（5）p->rchild!=T
（6）p=p->rchild
（7）p=p->rchild
3. （8）T==NULL
（9）T->lchid
（10）T->rchild
六、编写算法
a[low]=a[high];
while(low<high&&a[low]<key])
low++;
a[high]=a[low];
}
a[low]=p;
}
2. （1）构建 Huffman 树的代码如下：
#include <iostream>
#include <cstdlib>
using namespace std;
}
while(length>1){//数组中节点个数大于 1 时循环
int i,j;
findMin(t,length,i,j);
mergeTreeNode(t,length,i,j);
}
int ans = 0;
traverse(t[0],0,ans);
cout << endl;
cout << "ans=" << ans << endl;
10. D
11. D
12. A
【解答】无向图没有方向,所以相应的邻接矩阵是对称的
13. D
14. C
15. A
二、
填空题
1. n-i
2. (SQ.front+1)%(m+1)
3. p->next=q->next
free(q)
4. (n+1)
5. 89
6. O(log2 )
O(nlog2 )
7. d
}
for(int k = 0; k < length; k++){
if(k!=min && T[k]->weight < T[second_min]->weight){
second_min = k;
}
}
i = min > second_min ? second_min:min;
j = min > second_min ? min:second_min;
4.（1）邻接表如下：
（2）按克鲁斯卡尔（Kruskal）算法求其最小生成树，其过程如下：
5. （1）若采用 shell 排序，第一趟结构为：
(142,111,123,65,102,879,572,434,543,242,811,453)。
（2）初始堆为：
初始堆第一趟排序的结果为：(142,543,123,65,453,879,572,434,111,242,811,102)。