中国大学MOOC-陈越、何钦铭-数据结构-2018春期中考试

判断题:

1-1 所谓“循环队列”是指用单向循环链表或者循环数组表示的队列。 (2分)

F：将向量空间想象为一个首尾相接的圆环，并称这种向量为循环向量。存储在其中的队列称为循环队列（Circular Queue）。这种循环队列可以以单链表的方式来在实际编程应用中来实现。因此，循环队列是一个抽象的数据结构，而单向循环链表或循环数组是具体的实现方式，不是数据结构本身。

1-2 将1、2、3、4、5、6顺序插入初始为空的AVL树中，当完成这6个元素的插入后，该AVL树的先序遍历结果是：4、2、1、3、5、6。 (3分)

T：按照AVL树的旋转方法，得到AVL树，最后的结果就是4 2 1 3 5 6.

1-3 如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G中一定有回路。 (3分)

F：没有必然关系，正确的结论应该是一定有两个联通子图，这里的反例是两个点无路径，但没回路，两次BFS也能访问所有点

1-4 某二叉树的后序和中序遍历序列正好一样，则该二叉树中的任何结点一定都无右孩子。 (3分)

T：后序遍历的顺序是“左孩子->右孩子->根结点”，中序遍历的顺序是“左孩子->根结点->右孩子”，所以没有右孩子的情况下才一样。

1-5 算法分析的两个主要方面是时间复杂度和空间复杂度的分析。 (2分)

T：正确

1-6 无向连通图至少有一个顶点的度为1。 (3分)

F：对顶点数n≥3的无向完全图，不存在度为1的顶点，并且边数与顶点数的差要大于等于0。最简单的例子就是三个结点，两两之间有边。

1-7 将$N$个数据按照从小到大顺序组织存放在一个单向链表中。如果采用二分查找，那么查找的平均时间复杂度是$O(logN)$。 

F：这题的基础是建立在单向链表的基础上，单向链表是数据在链表中的位置只能通过从头到尾的顺序检索得到，即使是有序的，要操作其中的某个数据也必须从头开始，这和数组有本质的不同。

1-8 一棵有124个结点的完全二叉树，其叶结点个数是确定的。 (3分)

T：完全二叉树要按照从左到右，从上到下的规则插入元素，因此他的结构是唯一的，所以叶结点的个数是确定的

1-9 在一棵二叉搜索树上查找63，序列39、101、25、80、70、59、63是一种可能的查找时的结点值比较序列。 (3分)

F：二叉搜索树，左子树中的元素最大值一定小于根结点，根结点一定小于右子树元素最小值。而63比39大，要从右子树去找，但是出现了25<39，因此是不符合的。

1-10 若一个栈的输入序列为{1, 2, 3, 4, 5}，则不可能得到{3, 4, 1, 2, 5}这样的出栈序列。 (3分)

T：Push 1，Push 2，Push 3， Pop 3， Push 4，Pop 4，显然继续下去要想下一个出栈的元素是1是不可能的。

选择题：

2-1 已知一棵二叉树的先序遍历结果是ABC，则以下哪个序列是不可能的中序遍历结果： (4分)

     A.ABC        B.BAC        C.CBA        D.CAB

答案：D     解：A对应结点全在右子树上的树，B对应对应满二叉树ABC，C对应结点全在左子树上的树

2-2 若用大小为6的数组来实现循环队列，且当前front和rear的值分别为0和4。当从队列中删除两个元素，再加入两个元素后，front和rear的值分别为多少？ (4分)

     A.2和2        B.2和0        C.2和4        D.2和6

答案：B     解：front=(0+2)%6, rear=(4+2)%6

2-3 一棵二叉树中，双分支结点数为15，单分支结点数为30，则叶子结点数为（）个。 (4分)

    A.16            B.17           C.15            D.47

答案：A    解：双分支结点数为叶子结点数-1，因此叶子结点数为16

2-4 将6、4、3、5、8、9顺序插入初始为空的最大堆（大根堆）中，那么插入完成后堆顶的元素为： (4分)

    A.6             B.9              C.3              D.5

答案：B    解：堆顶的一定是最大元素

2-5 若借助堆栈将中缀表达式a+b*c+(d*e+f)*g转换为后缀表达式，当读入f时，堆栈里的内容是什么（按堆栈自底向上顺序）？ (4分)

   A.++(+       B.+(*+        C.+(+          D.abcde

答案：C    解：当遇到第二个+的时候，由于前面是*，优先级低于*，因此*出栈，而与第一个+同优先级，第一个+也要出栈，此时栈中还剩一个+，继续加入(，*，遇到第三个+，优先级低于*，因此*出栈，下一步读到f，此时栈中为+(+。

2-6 给定$N\times N\times N$的三维数组A，则在不改变数组的前提下，查找最小元素的时间复杂度是：(4分)

   A.O(N^3logN)

   B.O(N^3)

   C.O(N^2)

   D.O(NlogN)

答案：B    解：一个个遍历过去，时间复杂度就是N^3

2-7 下列函数中，哪个函数具有最慢的增长速度：(4分)

   A.N(logN)^2

   B.N^1.5

   C.NlogN^2

   D.N^2logN

答案：C    解：显然在AC中选，可以通过A=C解方程组就可以发现C更慢

2-8 设一段文本中包含字符{a, b, c, d, e}，其出现频率相应为{3, 2, 5, 1, 1}。则经过哈夫曼编码后，文本所占字节数为： (4分)

   A.36          B.12          C.40          D.25

答案：D    解：5*1+3*2+2*3+1*4+1*4=25

2-9 设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(4分)

   A.h=t; t->next=h;

   B.t->next=h; h=t;

   C.h=t; t->next=h->next;

   D.t->next=h->next; h=t;

答案：B    解：t->next=h，令t作为h新的头，再用h=t，就实现了h的头上插入一个新结点，而这单向链表仍是h

2-10 给定程序时间复杂度的递推公式：$T(1)=1$，$T(N)=2T(N/2)+N$。则程序时间复杂度是：(4分)

   A.$O(Nlog_2N)$

   B.$O(N^2)$

   C.$O(log_2N)$

   D.$O(N)$

答案：A    解：可以直观得看，递推公式多出来一个N，递推经过logN次结束，因此时间复杂度就是NlogN

2-11 在并查集问题中，已知集合元素0~8所以对应的父结点编号值分别是{ 1, -4, 1, 1, -3, 4, 4, 8, -2 }（注：$-n$表示树根且对应集合大小为$n$），那么将元素6和8所在的集合合并（要求必须将小集合并到大集合）后，该集合对应的树根和父结点编号值分别是多少？ (4分)

   A.4和-5          B.8和-5          C.8和-6          D.1和-6

答案：A    元素6所在的集合相较于8所在的几何是大集合，元素6的父结点是4，合并元素8所在的集合后，元素个数为5，因此编号为-5

2-12 在一个用数组表示的完全二叉树中，如果根结点下标为1，那么下标为17和19这两个结点的最近公共祖先结点在哪里（数组下标）？ （注：两个结点的“公共祖先结点”是指同时都是这两个结点祖先的结点） (4分)

   A.4                 B.2                 C.1                 D.8

答案：A    解，直接画图就可以知道。或者是用19和17一直除以2，取下整，当结果相同时就是答案

程序填空题：（注意别把分号写上去。。我就这么错了三个）

5-1下列代码的功能是返回带头结点的单链表L的逆转链表。

List Reverse( List L )
{
    Position Old_head, New_head, Temp;
    New_head = NULL;
    Old_head = L->Next;

    while ( Old_head )  {
        Temp = Old_head->Next;
        (6分);  
        New_head = Old_head;  
        Old_head = Temp; 
    }
    (6分);
    return L;
}

解：Old_head->next=New_head，做的是把Old_head指针指向前一个元素，当New_head为Null时，Old_head也指向Null，此时的Old_head就是反转链表后的尾结点。  L->next=New_head，使该链表以L为头结点。

5-2下列代码的功能是从一个大顶堆H的某个指定位置p开始执行下滤。

void PercolateDown( int p, PriorityQueue H )
{
   int  child;
   ElementType  Tmp = H->Elements[p];
   for ( ; p * 2 <= H->Size; p = child ) {
      child = p * 2;
      if ( child!=H->Size && (6分) )
         child++;
      if ( H->Elements[child] > Tmp )
         (6分);
      else  break;
   }
   H->Elements[p] = Tmp; 
}

解：H->Elements[child+1]>H->Elements[child]表示如果右孩子比左孩子大，就把结点移到右孩子上。

      H->Elements[p]=H->Elements[child]如果孩子结点比父亲结点大，那么父亲结点的位置就为孩子结点。