数据结构期末考试试卷(A卷)

数据结构期末考试试卷（A卷）
第一学期
开课单位：软件学院 ,考试形式：闭、开卷,允许带入场
I。

基本概念部分(共60分）
1 下图所示是单链表结点的插入过程，在fence结点后面插入一个值为10的ltmp结点，已知fence—>next是指向fence的后继结点，请把这一插入过程用代码表示出来：（6分)
这一过程的代码:
ltmp—〉next = fence—>next；
fence—>next = ltmp;
2 下图所示是双链表结点的删除过程，在fence结点后面删除一个值为23的结点，已知fence->next是指向fence的后继结点，fence —>prev是指向fence的前驱结点,ltmp是一个值为NULL的链表结点指针，请把这一删除过程用代码表示出来：（8分)
这一过程的代码：
ltmp = fence—〉next;
fence-〉next = ltmp—>next;
ltmp->next—>prev = fence；
3 画出下图中的BST加上值5以后的形状.(6分）
4 画出下图所示图的相邻矩阵表示(假设下面的表格是一个二维数组，请在表格中填入正确的数值）.（8分）
5 给出下图从顶点1开始的DFS 树。

(8分）
6
（最小生成树）。

(8分)
7 :(8分）
］， int n){
for （int i = 0; i 〈 n ； i++）
{
； j++)｛
if(A ［i ｛ tmp = A[i ］;
A ［i ］ = A ［j ］；
A[j] = tmp; } }
//外层循环，打印一下中间结果
for （int k = 0； k < n; k++) printf(” %d",A[k］）; printf （”\n”）; } ｝
int A［] = { 9, 12，3,7，90，15};
8 给出从下图的最大值堆中删除最大元素后得到的堆.（8分）
或
II。

1
//合并两个有序的单链表为一个新的有序的单链表，
//传入参数为两个有序的单链表，返回合并后的有序表。

template<class Elem〉
List〈Elem〉＊ merge（List<Elem>＊ l1， List<Elem〉＊ l2) { l1-〉setStart（);
l2—〉setStart（）；
List<Elem〉 *l = new LList<Elem〉（);
Elem e1， e2;
//按顺序把两个表中的元素放入新表中
while (l1->getValue（e1）＆& ⑴）｛//12->getValue(e2) if (e1 < e2） {
l-〉append（e1）；
l1—>next()；
｝ else {
l—〉append（e2);
l2—>next(）；
} //end if—else
｝//end while
//如果表l1不为空，则把剩余的元素都放入新表中
while (l1->getValue(e1）) {
⑵ ; //1->append（e1)
l1—〉next(）；
//如果表l2不为空,则把剩余的元素都放入新表中
while (l2—〉getValue（e2））｛
l—>append(e2);
l2->next()；
}
//返回新生成的表
return ⑶1; //List〈Elem〉*1(错）
}
2 回文（palindrome）是指一个字符串从前面读和从后面读都一样。

仅使用若干栈和队列、栈和队列的ADT函数以及若干个int类型和char类型的变量，下面的算法能判断一个字符串是否为回文.算法的返回结果为true或false。

bool isPal（char *buf)｛
//声明一个空栈和一个空队列
Queue〈char〉＊q;
Stack<char〉＊s；
char cq，cs；
//初始化栈和队列
s = new AStack<char〉(BUFLEN);
q = new AQueue<char〉(BUFLEN)；
//把字符串中的字符一个一个分别入栈和入队
for(int i = 0; i〈strlen（buf）； i++）｛
s->push(buf[i])；
⑷; // q->enqueue(buf[i])
}
//出栈出队，比较
while（q—〉dequeue（cq) &＆⑸）{ // s->pop（cs）if（cq ！= cs） return false;
｝
return ⑹; // true
}
3 下面是一个递归函数search，传入参数为一棵二叉树和一个值K，如果值K出现在树中则返回true,否则返回false。

template〈class Elem， class KEComp>
bool search(BinNode<Elem〉＊rt， int K）；
template〈class Elem, class KEComp〉
bool search(BinNode<Elem> *rt, int K）｛
if(rt == NULL) return ⑺; // false
else{
if（KEComp：：eq（K，rt—〉val(）)) return true；
else{
return ⑻ ; // false(错)
｝//search（rt->left(),K）｜| search(rt-〉right(），K）}
｝
4 下面是一个递归函数smallcount，传入一棵二叉检索树和值K,返回值小于或等于K的结点数目。

template〈class Key， class Elem， class KEComp〉
int smallcount(BinNode<Elem> *root, Key K）；
template<class Key, class Elem， class KEComp>
int smallcount（BinNode〈Elem> *root， Key K）{
if （root == NULL) return ⑼0; // false
else{
if（KEComp：：lt（K,root->val（）)){
return smallcount（root—>left（),K）；
｝
else{
return⑽；// smallcount(root->right(),K)（错) ｝//1 + smallcount（root-〉left()，K） + smallcount（root-〉right （），K)
}
}
注:返回值,如果是int型则返回0或1，如果是bool型则返回false或true 5 写一个算法以确定有n个顶点的无向图是否包含回路，代码已经给出，其中空位的地方需要你来补上。

//判断是否存在环的方法，检查所有可能的连通分量
#define UNVISITED 0
＃define VISITED 1
bool isExistRing（Graph* G) ｛
bool br = false；
for （int v = 0；⑾； v++) { // v<G-〉n （）
//考虑图的所有顶点
if （⑿ == UNVISITED）｛//G—>getmark(v) br = br ｜｜ LookRing(G， 0， -1）;
}
｝
return br；
}
/*
＊从顶点pre开始,利用深度优先搜索
*在同一个连通分量类，如果找到了一个曾经被访问过的顶点
＊即说明此无向图存在环
＊/
bool LookRing（Graph＊ G, int v， int pre）｛
bool br = false;
⒀ G—>setmark（v，VISITED)； //设置该顶点被访问
for (int w = G-〉first(v); w < ⒁G—>e()； w = G->next(v,w)）｛
if (⒂ == VISITED） { //G->getmark(W）if (w != pre）
br = true; //存在环
｝ else
br = br || LookRing（G， w， v）; //对每一个可能边再找｝
return br;
｝
⑴ l2—>getValue(e2）
⑵ l->append（e1）
⑶ l
⑷ q-〉enqueue(buf[i］）
⑸ s—>pop(cs)
⑹ true
⑺ false
⑻ search(rt-〉left()，K) |｜ search（rt->right（）,K）
⑼ 0
⑽ 1 + smallcount（root-〉left（）,K） + smallcount(root—〉right(）,K）⑾ v < G—>n(）
⑿ G—>getMark（v)
⒀ G-〉setMark(v, VISITED)
⒁ G->e(）
⒂ G—〉getMark(w)
Ш. 综合问题求解(共10分）
1 编写一个函数，以一棵树为输入，返回树的结点数目，函数原型如下：（10分）
template 〈class Elem> int nodeCount（GTNode〈Elem〉* rt）；
template <class Elem〉
int nodeCount（GTNode<Elem〉* rt）{
int n = 1；
if（rt == NULL) return 0；
else{
for（GTNode〈Elem>＊ tmp = root-〉leftmost_child（);
tmp != NULL；
tmp = tmp—>right_sibling（））｛
n += nodeCount（tmp)；
｝
｝
return n；
｝。