数据结构期末考试复习资料(选择判断)

 

数据的逻辑结构是指数据的各数据项之间的逻辑关系。

X,逻辑结构就是数据元素间的逻辑关系,而不是数据元素内部的数据项之间的关系.

抽象数据类型中基本操作的定义与具体实现有关

X,抽象数据结构类型不需要考虑其包含的数据对象和在不同处理器中的表现和实现细节

数据的（）包括集合、线性结构、树形结构和图形结构四种基本类型。 (2分)
A.存储结构
B.逻辑结构
C.基本运算
D.算法描述
B


数据在计算机内存中的表示是指（） 。 (2分)
A.数据的存储结构
B.数据结构
C.数据的逻辑结构
D.数据元素之间的关系
A


下列关于数据的逻辑结构的叙述中，（）是正确的。(2分)
A.数据的逻辑结构是数据元素间关系的描述
B.数据的逻辑结构反映了数据在计算机中的存储方式
C.数据的逻辑结构分为顺序结构和链式结构
D.数据的逻辑结构分为静态结构和动态结构
A		

数据结构是一门研究非数值计算的程序设计问题中计算机的（）以及它们之间的关系和运算等的学科。 (2分)
A.操作对象
B.计算方法
C.逻辑存储
D.数据映象
A


在数据结构中，与所使用的计算机无关的数据结构是（）。 (2分)
A.逻辑结构
B.存储结构
C.逻辑结构和存储结构
D.物理结构
A

线性结构中元素之间存在（）关系。 (2分)
A.一对一
B.一对多
C.多对多
D.多对一
A


树形结构中元素之间存在（）关系。 (2分)
A.一对一
B.一对多
C.多对多
D.多对一
B


图形结构中元素之间存在（）关系。 (2分)
A.一对一
B.一对多
C.多对多
D.多对一
C


从物理存储上可以把数据结构分为 (2分)
A.动态结构、静态结构
B.顺序结构、链式结构
C.线性结构、树形结构、图形结构和集合结构
D.基本结构、构造型结构
B
从物理结构上数据结构分为 ：．顺序存储结构、链式存储结构 （有时也还有索引结构）
从逻辑结构上数据结构分为 ：线性结构（例如线性表,栈,队列）、非线性结构 （图 ,树） 
索引存储方式和散列存储 也是属于物理结构

与数据元素本身的形式、内容、相对位置、个数无关的是数据的（ ）。 (1分)
A.存储结构
B.存储实现
C.逻辑结构
D.运算实现
C

通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（ ）。 (1分)
A.数据在同一范围内取值
B.不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致
C.每个数据元素都一样
D.数据元素所包含的数据项的个数要相等
B

以下说法正确的是（ ）。 (1分)
A.数据元素是数据的最小单位
B.数据项是数据的基本单位
C.数据结构是带有结构的各数据项的集合
D.一些表面上很不相同的数据可以有相同的逻辑结构
D
数据元素是数据的基本单位，数据项是数据的最小单位，数据结构是带有结构的

各数据元素的集合。


在存储数据时，通常不仅要存储各数据元素的值，而且还要存储（）。 (1分)
A.数据的处理方法
B.数据元素的类型
C.数据元素之间的关系
D.数据的存储方法
C

(NlogN)/1000是O(N)的。 
 X，只看未知数的方程式。

下列函数
int func ( int n )
{   int i = 0, sum = 0;
    while ( sum < n )  sum += ++i;
    return i;
}
的时间复杂度是：(2分)
A.O(logn)
B.O(n​1/2​​)
C.O(n)
D.O(nlogn)
B，sum=1+2+3+4.。。。是以N的平方速度增长的，所以时间复杂度为根号n

for(i=0; i<n; i++)
  for(j=i; j>0; j/=2)
     printf(“%d\n”, j);
的时间复杂度是： (3分)
A.O(N×i)
B.O(N)
C.O(N​2​​)
D.O(NlogN)
D，先看最内层循环，假设i=n，执行j=n，j/=2的操作，此时循环次数由n为2的多少次方决定，复杂度为logn，外层为n，相乘则为logn*n；
下列函数中，哪个函数具有最慢的增长速度：(2分)
A.N​1.5​​
B.NlogN​2​​
C.N​2​​logN
D.N(logN)​2​​
B，这个得自己算算就是取几个数带进去
计算机算法必须具备输入、输出和（）等五个特性。 (2分)
A.可行性、可移植性和可扩充性
B.可行性、确定性和有穷性
C.确定性、有穷性和稳定性
D.易读性、稳定性和安全性
B
线性表L在什么情况下适用于使用链式结构实现？ (1分)
A.需不断对L进行删除插入
B.需经常修改L中的结点值
C.L中含有大量的结点
D.L中结点结构复杂
A

链表不具有的特点是： (1分)
A.插入、删除不需要移动元素
B.方便随机访问任一元素
C.不必事先估计存储空间
D.所需空间与线性长度成正比

B
设h为不带头结点的单向链表。在h的头上插入一个新结点t的语句是：(1分)
A.h=t; t->next=h->next;
B.t->next=h->next; h=t;
C.h=t; t->next=h;
D.t->next=h; h=t;
D

不带表头附加结点的单链表为空的判断条件是头指针head满足条件（）。 (1分)
A.head==NULL
B.head->next==NULL
C.head->next== head
D.head!=NULL
A

可以用带表头附加结点的链表表示线性表，也可以用不带头结点的链表表示线性表，前者最主要的好处是（）。 (1分)
A.可以加快对表的遍历
B.使空表和非空表的处理统一
C.节省存储空间
D.可以提高存取表元素的速度
B

在单链表中，要删除某一指定结点，必须先找到该结点的（）。 (1分)
A.直接前驱
B.自身位置
C.直接后继
D.直接后继的后继

A,注意这里是单链表。

若某线性表最常用的操作是存取任一指定序号的元素和在最后进行插入和删除运算，则利用顺序表存储最节省时间。 (2分)

T，注意这里说的是在最后进行插入和删除操作

对于顺序存储的长度为N的线性表，删除第一个元素和插入最后一个元素的时间复杂度分别对应为O(1)和O(N)。 (1分)
F,写反了

(neuDS)顺序存储的线性表不支持随机存取.
F,随机存取（有时亦称直接访问）代表同一时间访问一组序列中的一个随意组件

顺序表中第一个元素的存储地址是100，每个元素的长度为2，则第5个元素的地址是（ ）。(2分)
A.100
B.105
C.108
D.110
C,公式 a0+len*(n-1);

若长度为n的线性表采用顺序存储结构，那么删除它的第i个数据元素之前，需要它一次向前移动（）个数据元素。 (2分)
A.n-i
B.n+i
C.n-i-1
D.n-i+1
A,线性表顺序存储结构删除第i个元素，需将i以后的元素都向前移动一个位置，所以是n-i个元素。

若长度为n的线性表采用顺序结构，在第i个数据元素之前插入一个元素，需要它依次向后移动（）个元素。 (2分)
A.n-i
B.n-i+1
C.n-i-1
D.i
B,注意这里是插入一个元素，原理和上面那个题目一样。

线性表L=（a1, a2 ,……，an ）用一维数组表示，假定删除线性表中任一元素的概率相同（都为1/n），则删除一个元素平均需要移动元素的个数是（）。 (2分)
A.n/2
B.(n+1)/2
C.(n-1)/2
D.n
C，需要移动的总次数为n*(n-1)/2,除以n得平均次数。

在具有N个结点的单链表中，访问结点和增加结点的时间复杂度分别对应为O(1)和O(N)。 (1分)
F,https://blog.csdn.net/gaoxiangnumber1/article/details/44634485

带头结点的单链表h为空的判定条件是： (2分)
A.h == NULL;
B.h->next == NULL;
C.h->next == h;
D.h != NULL;
B

将长度为n的单链表连接在长度为m的单链表之后的算法的时间复杂度为（ ）。 (2分)
A.O(1)
B.O(m)
C.O(n)
D.O(n+m)
B,就相当于把m链表给遍历一遍，目的是找到m的末尾与n的头节点相连接。

(neuDS)在单链表中，增加一个头结点的最终目的是为了( )。 (2分)
A.使单链表至少有一个结点
B.方便运算的实现
C.标识表结点中首结点的位置
D.说明单链表是线性表的链式存储
B

插播知识点，注意顺序表，与链表均属于线性表。

在双向循环链表结点p之后插入s的语句是： (3分)
A.p->next=s; s->prior=p; p->next->prior=s ; s->next=p->next;
B.p->next->prior=s; p->next=s; s->prior=p; s->next=p->next;
C.s->prior=p; s->next=p->next; p->next=s; p->next->prior=s;
D.s->prior=p; s->next=p->next; p->next->prior=s; p->next=s;
D

某线性表中最常用的操作是在最后一个元素之后插入一个元素和删除第一个元素，则采用什么存储方式最节省运算时间？ (2分)
A.单链表
B.仅有尾指针的单循环链表
C.仅有头指针的单循环链表
D.双链表
D解析：
链式存储有：单链表(线性链表)、循环链表、双向链表。
单链表从链表的第一个表元开始，将线性表的节点依次存储在链表的各表元中。链表的每个表元除要存储线性表节点信息外，还要一个成分用来存储其后继节点的指针。
循环链表是单链表的变形，其特点是表中最后一个节点的指针域指向头节点，整个链表形成一个环。
因此，从表中的任意一个节点出发都可以找到表中的其他节点。循环链表中，从头指针开始遍历的结束条件不是节点的指针是否为空，而是是否等于头指针。为简化操作，循环链表中往往加入表头节点。
双向链表的节点中有两个指针域，其一指向直接后继，另一指向直接前驱，克服了单链表的单向性的缺点。

若某表最常用的操作是在最后一个结点之后插入一个结点或删除最后一个结点。则采用哪种存储方式最节省运算时间？ (2分)
A.单链表
B.双链表
C.单循环链表
D.带头结点的双循环链表
D,B选项依旧可以，但是效率并没有D高。

将线性表La和Lb头尾连接，要求时间复杂度为O(1)，且占用辅助空间尽量小。应该使用哪种结构？ (2分)
A.单链表
B.单循环链表
C.带尾指针的单循环链表
D.带头结点的双循环链表
C,循环链表中知道了末尾节点， 也就知道了头节点，所以只能考虑C,D，而题目中又说选择所占空间最小，所以选C,注意像这种题目中特意强调了头尾节点的，平时单说是没有头尾节点的。

(neuDS)在链表中若经常要删除表中最后一个结点或在最后一个结点之后插入一个新结点，则宜采用（）存储方式。 (2分)
A.顺序表
B.用头指针标识的循环单链表
C.用尾指针标识的循环单链表
D.双向链表
C，注意循环单链表中知道头指针是无法获得尾指针的，而从空间综合考虑选C。

在一个长度为n（n>1）的单链表上，设有头和尾两个指针，执行（）操作与链表的长度有关。 (2分)
A.删除单链表中的第一个元素
B.删除单链表中的最后一个元素
C.在单链表第一个元素前插入一个新元素
D.在单链表最后一个元素后插入一个新元素
B，这个题很容易晃人，就B来说删是很好删的，但是删完需要将他的前驱进行改变，但这可是单链表啊，所以与长度有关

如果对线性表的运算只有4种，即删除第一个元素，删除最后一个元素，在第一个元素前面插入新元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)
A.只有表尾指针没有表头指针的循环单链表
B.只有表尾指针没有表头指针的非循环双链表
C.只有表头指针没有表尾指针的循环双链表
D.既有表头指针也有表尾指针的循环单链表
C

如果对线性表的运算只有2种，即删除第一个元素，在最后一个元素的后面插入新元素，则最好使用（）。 (2分)
A.只有表头指针没有表尾指针的循环单链表
B.只有表尾指针没有表头指针的循环单链表
C.非循环双链表
D.循环双链表
B，理由参考上面都差不多的原理，不多重复

带表头附加结点的双向循环链表为空的判断条件是头指针L满足条件（）。(2分)
A.L= =NULL
B.L->right= =NULL
C.L->left = =NULL
D.L->right= =L
D，这个题不难，但是很容易错，注意细节仔细想想。

循环链表的主要优点是（）。 (2分)
A.不再需要头指针了
B.已知某个结点的位置后，能够很容易找到它的直接前驱
C.在进行插入、删除运算时，能更好的保证链表不断开
D.从表中的任意结点出发都能扫描到整个链表
D

已知指针ha和hb分别是两个单链表的头指针，下列算法将这两个链表首尾相连在一起，并形成一个循环链表（即ha的最后一个结点链接hb的第一个结点，hb的最后一个结点指向ha），返回该循环链表的头指针。请将该算法补充完整。 (4分)
typedef struct node{
ElemType data;
    struct node *next;
}LNode;
LNode *merge(LNode *ha, LNode *hb) {
LNode *p=ha;
     if (ha==NULL || hb==NULL) {
cout<<”one or two link lists are empty!”<<endl;
          return NULL;
     }
     while ( p->next!=NULL ) 
           p=p->next;
     p->next=hb;
     while ( p->next!=NULL ) 
           p=p->next;
           __________         
}

A.ha=p->next; return ha;
B.p->next=ha; return ha;
C.ha=p->next; return p;
D.p->next=ha; return p;
B

与单链表相比，双链表的优点之一是（）。 (2分)
A.插入、删除操作更加简单
B.可随机访问
C.可以省略表头指针或表尾指针
D.顺序访问相邻结点更加灵活
D

采用多项式的非零项链式存储表示法，如果两个多项式的非零项分别为N​1​​和N​2​​个，最高项指数分别为M​1​​和M​2​​，则实现两个多项式相乘的时间复杂度是：(2分)
A.O(N​1​​×N​2​​)
B.O(M​1​​×M​2​​)
C.O(N​1​​+N​2​​)
D.O(M​1​​+M​2​​)
A，本质还是N个数与N个数相乘，而且是链式储存法。

给定一个堆栈的入栈序列为{ 1, 2, ⋯, n }，出栈序列为{ p​1​​, p​2​​, ⋯, p​n​​ }。如果p​2​​=n，则存在多少种不同的出栈序列？(2分)
A.1
B.2
C.n−1
D.N
C，p2=n,说明之前肯定提前弹出了一个，从n-1个数里挑一个就OK。

从栈顶指针为ST的链栈中删除一个结点且用X保存被删结点的值，则执行： (2分)
A.X= ST->data;
B.X= ST; ST = ST->next;
C.X= ST->data; ST = ST->next;
D.ST = ST->next; X= ST->data;
C

若一个栈的入栈序列为1、2、3、…、N，输出序列的第一个元素是i，则第j个输出元素是： (2分)
A.i−j−1
B.i−j
C.j−i−1
D.不确定
C，只告诉你入栈顺序，基本啥也确定不了。

若一个栈的入栈序列为1、2、3、…、N，其输出序列为p​1​​、p​2​​、p​3​​、…、p​N​​。若p​1​​=N，则p​i​​为： (2分)
A.i
B.n−i
C.n−i+1
D.不确定
C,就是正常的出栈顺序。

将5个字母ooops按此顺序入栈，则有多少种不同的出栈顺序可以仍然得到ooops？ (2分)
A.1
B.3
C.5
D.6
D，最后两个字母的顺序肯定不变了，就看前面这三个o怎么出来的，可以进一个出一个记为1，满两个出两个记为2，满三个出三个记为3，满两个出一个记为4，排列组合一下，111，141，12，21，3.

线性表、堆栈、队列的主要区别是什么？(1分)
A.线性表用指针，堆栈和队列用数组
B.堆栈和队列都是插入、删除受到约束的线性表
C.线性表和队列都可以用循环链表实现，但堆栈不能
D.堆栈和队列都不是线性结构，而线性表是
B

插播知识点，对于队列来说，刚进来的地方是未，要出去的地方是头。


在用数组表示的循环队列中，front值一定小于等于rear值。 (1分)
F

不论是入队列操作还是入栈操作,在顺序存储结构上都需要考虑"溢出"情况。 (2分)
T

关于循环队列，可以参考这几篇资料：
https://baike.baidu.com/item/%E5%BE%AA%E7%8E%AF%E9%98%9F%E5%88%97/3685773?fr=aladdin
https://blog.csdn.net/lpp0900320123/article/details/20694409

若用大小为6的数组来实现循环队列，且当前front和rear的值分别为0和4。当从队列中删除两个元素，再加入两个元素后，front和rear的值分别为多少？ (2分)
A.2和0
B.2和2
C.2和4
D.2和6
A，答案见上面的博客。(rear+1)%n==front

如果循环队列用大小为m的数组表示，队头位置为front、队列元素个数为size，那么队尾元素位置rear为： (2分)
A.front+size
B.front+size-1
C.(front+size)%m
D.(front+size-1)%m
D，(rear+1)%n==front

函数strcmp从头至尾顺序地将其对应字符比较，遇到两个字符不等时，两个字符相减得到一个int型值，两个字符串完全相同时，则返回0。 (1分)
T

Among the following assignments or initializations, __ is wrong. (2分)
A.char str[10]; str="string";
B.char str[]="string";
C.char *p="string";
D.char *p; p="string";
A

Java语言中的数组元素下标总是从0开始，下标可以是整数或整型表达式。
T

在对数组全部元素赋初值时，不可以省略行数，但能省略列数。 (1分)
F

以下数组定义中错误的是（ ）。 (2分)
A.int x[][3]={0};
B.int x[2][3]={{1,2},{3,4},{5,6)};
C.int x[][3]={{1,2,3},(4,5,6)};
D.int x[2][3]={1,2,3,4,5,6};
B，主要是看看A选项，还真没咋见过

存在一棵总共有2016个结点的二叉树，其中有16个结点只有一个孩子。
F，不知道树的特点无法进行求解

若A和B都是一棵二叉树的叶子结点，则存在这样的二叉树，其前序遍历序列为...A...B...，而中序遍历序列为...B...A...。

F，B不可能在A之前，因为前序中序遍历改变的仅仅是左子树与父节点的位置；

若一个结点是某二叉树的中序遍历序列的最后一个结点，则它必是该树的前序遍历序列中的最后一个结点。
F，若最后一个节点是根节点，则不行

如果一棵非空k（k≥2）叉树T中每个非叶子结点都有k个孩子，则称T为正则k叉树。若T的高度为h（单结点的树h=1），则T的结点数最多为：(3分)
A.(k​h​​−1)/(k−1)
B.(k​h−1​​−1)/(k−1)
C.(k​h+1​​−1)/(k−1)
D.以上都不是
A，等比数列求和公式，Sn=a1*(1-q^n)/(1-q).

如果一棵非空k（k≥2）叉树T中每个非叶子结点都有k个孩子，则称T为正则k叉树。若T的高度为h（单结点的树h=1），则T的结点数最少为：(3分)
A.(k​h−1​​−1)/(k−1)+1
B.(k​h​​−1)/(k−1)−1
C.kh
D.k(h−1)+1
D,T为一颗正则树，然后我们每层只允许一个节点继续往下分，直至到达高度h，所以为D，后面的+1加的是根节点那个1.

已知一棵二叉树的树形如下图所示，其后序序列为{ e, a, c, b, d, g, f }。树中与结点a同层的结点是：(3分)
A.c
B.d
C.f
D.g
B,后序遍历：左，右，中。这是一个不断递归的过程，上面所给出的树的标记按层序输出是f,c,g,a,d,e,b.

只有2个结点的树的度为1.
T,刚开始没反应过来，这个数就俩节点，度数为1，没啥毛病。树的度：一棵树中，最大的节点的度称为树的度，节点的度就是看你有几颗子树；

若一棵二叉树的后序遍历序列是{ 1, 3, 2, 6, 5, 7, 4 }，中序遍历序列是{ 1, 2, 3, 4, 5, 6, 7 }，则下列哪句是错的？(3分)
A.这是一棵完全二叉树
B.2是1和3的父结点
C.这是一棵二叉搜索树
D.7是5的父结点
A，解析：
二叉树构建出来差不多就是这个样子。
完全二叉树：若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。
二叉搜索树：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树也分别为二叉排序树。

如果一棵非空k（k≥2）叉树T中每个非叶子结点都有k个孩子，则称T为正则k叉树。若T有m个非叶子结点，则T中的叶子结点个数为：(3分)
A.mk
B.m(k−1)
C.m(k−1)+1
D.m(k−1)−1
C,最初只有一个叶子结点，即根节点，随后每分叉一次就会减少一个叶子结点，但同时也会增加一个K个叶子结点

有一个四叉树，度2的结点数为2，度3的结点数为3，度4的结点数为4。问该树的叶结点个数是多少？(2分)
A.10
B.12
C.20
D.21
D,https://jingyan.baidu.com/article/9158e00035dba1a25512286f.html 学完这个就啥都会了

按照二叉树的定义，具有3个结点的二叉树有几种？ (2分)
A.3
B.4
C.5
D.6
C,https://blog.csdn.net/qiuqchen/article/details/23104385 依旧是一篇博客。

任何一棵二叉树的叶结点在先序、中序和后序遍历序列中的相对次序 (2分)
A.发生改变
B.不发生改变
C.不能确定
D.以上都不对
B

二叉树中第5层（根的层号为1）上的结点个数最多为：(2分)
A.8
B.15
C.16
D.32
C，2^(n-1)

先序遍历图示二叉树的结果为 (2分)

A.A，B，C，D，H，E，I，F，G
B.A，B，D，H，I，E，C，F，G
C.H，D，I，B，E，A，F，C，G
D.H，I，D，B，E，F，G，A，C
B,....这里讲的是先序遍历，别看错了...

某二叉树的前序和后序遍历序列正好相反，则该二叉树一定是 (2分)
A.空或只有一个结点
B.高度等于其结点数
C.任一结点无左孩子
D.任一结点无右孩子
B，由于先序遍历是“根――左子树――右子树”，而后序遍历是“左子树――右子树――根”，若某二叉树的先序和后序序列正好相反，则该二叉树每层左子树只能有1个，右子树不存在，即则该二叉树一定是高度等于其结点数。
突然意识到一个问题，树的“结点”是每个元素，而不是节点。。。规范一下

设n、m为一棵二叉树上的两个结点，在中序遍历时，n在m前的条件是 (3分)
A.n在m左方
B.n在m右方
C.n是m祖先
D.n是m子孙
A，可以自己模拟一下，左边的优先输出。

设高为h的二叉树（规定叶子结点的高度为1）只有度为0和2的结点，则此类二叉树的最少结点数和最多结点数分别为： (3分)
A.2h, 2​h​​−1
B.2h−1, 2​h​​−1
C.2h−1, 2​h−1​​−1
D.2​h−1​​+1, 2​h​​−1
B，就是把上面的K叉树改成了二叉树，其余的均相同。

对于一个有N个结点、K条边的森林，不能确定它共有几棵树。 
F：如果某棵树中有N0个结点,K0条边,则N0 = k0 + 1
设森林中有m棵树,其结点数分别为n1,n2,n3,.,nm
相应地,各棵树的边数分别为k1,k2,k3,...km
显然：n1 = k1 + 1,n2 = k2 + 1,.,nm = km + 1 (1)
按照题设：
n1 + n2 + n3 +.+ nm = N (2)
k1 + k2 + k3 +.+ km = K (3)
将(1) 代入(2) 得：
(k1 + 1) + (k2 + 1) + (k3 + 1) + .+ (km + 1) = N
即：
k1 + k2 + k3 + ...+ km + 1 + 1 +.+ 1 = N
按照(3)：
K+ m= N
于是m = N - K

具有1102个结点的完全二叉树一定有__个叶子结点。(3分)
A.79
B.551
C.1063
D.不确定
B：
首先继续安心的看百度百科：https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91/7773232?fr=aladdin
在百度百科里可以找到计算公式，问题解决，但是有个问题，为什么说完全二叉树度数为1的结点只能有1个或0个，仔细体会这句话：最下层上的结点都集中在该层最左边的若干位置上，完全二叉树，可以看做是满二叉树在最后一层从右往左砍掉一些节点。如果从满二叉树中在最后一层自左向右砍掉的节点数是偶数，那么该完全二叉树中度为1的节点数就是0。也就是说集中在左边的意思就是从出现第一个叶节点开始左边全是叶节点，完毕。

将森林转换为对应的二叉树，若在二叉树中，结点u是结点v的父结点的父结点，则在原来的森林中，u和v可能具有的关系是： (3分)
1.父子关系； 2. 兄弟关系； 3. u的父结点与v的父结点是兄弟关系
A.只有2
B.1和2
C.1和3
D.1、2和3
B：推荐一篇博客：https://blog.csdn.net/mengzhisuoliu/article/details/45038311
1，当他们是父子关系的时候，如果u有多个儿子，且v是他的第二个儿子，那么1得证，
2，当他们是兄弟关系时，u在v的左边两个，则2得证。
3，如果u，v的父亲是兄弟，那么不论如何变化，u，v都不可能有什么直接关系。

设森林F中有三棵树，第一、第二、第三棵树的结点个数分别为M​1​​，M​2​​和M​3​​。则与森林F对应的二叉树根结点的右子树上的结点个数是： (2分)
A.M​1​​
B.M​1​​+M​2​​
C.M​2​​+M​3​​
D.M​3​​
C，参考上面的那篇博客。

已知一棵完全二叉树的第6层（设根为第1层）有8个叶结点，则该完全二叉树的结点个数最多是： (3分)
A.39
B.52
C.111
D.119
C：列一下式子 1+2+4+8+16+32+(32-8)*2=111;
这里为了区分完全二叉树与满二叉树补充一个百度百科，https://baike.baidu.com/item/%E6%BB%A1%E4%BA%8C%E5%8F%89%E6%A0%91/7773283?fr=aladdin

具有65个结点的完全二叉树其深度为（根的深度为1）： (3分)
A.8
B.7
C.6
D.5
B：先按照满二叉树计算看算到第几层超了就最多是第几层，1+2+4+8+16+32=63，此时是6层，那么第七层稳超，所以是第七层。

在一个用数组表示的完全二叉树中，如果根结点下标为1，那么下标为17和19这两个结点的最近公共祖先结点在哪里（数组下标）？ （注：两个结点的“公共祖先结点”是指同时都是这两个结点祖先的结点） (3分)
A.8
B.4
C.2
D.1
B,数组的下标肯定都为整数，所以我们需要凑整数，数组中的储存方式为2*n+1,2*n,那么倒着找就是n/2,(n-1)/2，看哪个是整数就执行那个操作，得出结果B。

对N（≥2）个权值均不相同的字符构造哈夫曼树，则树中任一非叶结点的权值一定不小于下一层任一结点的权值。
 T：https://www.cnblogs.com/sench/p/7798064.html

对N（N≥2）个权值均不相同的字符构造哈夫曼树。下列关于该哈夫曼树的叙述中，错误的是： (2分)
A.树中一定没有度为1的结点
B.树中两个权值最小的结点一定是兄弟结点
C.树中任一非叶结点的权值一定不小于下一层任一结点的权值
D.该树一定是一棵完全二叉树
D，参考上面的博客

设一段文本中包含字符{a, b, c, d, e}，其出现频率相应为{3, 2, 5, 1, 1}。则经过哈夫曼编码后，文本所占字节数为： (2分)
A.40
B.36
C.25
D.12
C,依旧是一篇博客：https://blog.csdn.net/yuechuxuan/article/details/78034889

我们学习完博客之后，这道题可以构造成这个样子，然后进行编码，
a对应3：01   b对应2：001   c对应5：1  d对应1：0000  e对应1：0001，则所占用的文本就是他本身的编码长度*他出现的次数，2*3+3*2+1*5+4*1+4*1=25；

设一段文本中包含4个对象{a,b,c,d}，其出现次数相应为{4,2,5,1}，则该段文本的哈夫曼编码比采用等长方式的编码节省了多少位数？ (2分)
A.0
B.2
C.4
D.5
B：构造哈夫曼树，得出哈夫曼编码
a对应4：01  b对应2：001  c对应5：1
d对应1：000；
然后了解一下什么是等长编码：https://baike.baidu.com/item/%E7%AD%89%E9%95%BF%E7%A0%81/4339240
在等长编码中我们可以定义a:01 b:11 c:10 d:00
按照哈夫曼编码文本长度为2*4+2*3+5*1+1*3=22;
按照等长编码的文本长度为2*12=24；
答案为B；

哈夫曼树是n个带权叶子结点构成的所有二叉树中（）最小的二叉树。 (2分)
A.权值
B.高度
C.带权路径长度
D.度
C

(neuDS)在哈夫曼树中，任何一个结点它的度都是（ ）。 (2分)
A.0或1
B.1或2
C.0或2
D.0或1或2
C

无向连通图至少有一个顶点的度为1。
F，https://baike.baidu.com/item/%E8%BF%9E%E9%80%9A%E6%97%A0%E5%90%91%E5%9B%BE/3638067
依旧是一篇百度百科，可以存在环

用邻接表法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。
F
用邻接矩阵法存储图，占用的存储空间数只与图中结点个数有关，而与边数无关。
 T

在一个有向图中，所有顶点的入度与出度之和等于所有边之和的2倍。 
 T

如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则G中一定有回路。
F，有两个连通分量
无向连通图所有顶点的度之和为偶数。
T，边数*2必为偶数。
无向连通图边数一定大于顶点个数减1。
F，也可以等于

若无向图G =（V，E）中含10个顶点，要保证图G在任何情况下都是连通的，则需要的边数最少是： (3分)
A.45
B.37
C.36
D.9
B ，把题目的意思翻译一下，给你是个点，最少有多少个边，不管你怎么连，他总是连通的。然后是思路，最小的遍数应该是把剩余9个点完全连通，剩下一个孤立点，此时不论你怎么连都是联通的。
至于怎么求完全图的边数，继续附上一篇博客，https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E5%9B%BE/10073908?fr=aladdin

给定一个有向图的邻接表如下图，则该图有__个强连通分量。(3分)

A.4 {{0, 1, 5}, {2}, {3}, {4}}
B.3 {{2}, {4}, {0, 1, 3, 5}}
C.1 {0, 1, 2, 3, 4, 5}
D.1 {0, 5, 1, 3}
B，首先什么是强连通分量，附上一篇博客与百度百科，https://www.cnblogs.com/five20/p/7594239.html
https://baike.baidu.com/item/%E5%BC%BA%E8%BF%9E%E9%80%9A%E5%88%86%E9%87%8F/7448759?fr=aladdin

再来一张很帅气的图片，慢慢找就可以。
给定有向图的邻接矩阵如下：

顶点2（编号从0开始）的出度和入度分别是：(1分)
A.3, 1
B.1, 3
C.0, 2
D.2, 0
C，在邻接矩阵中，出度为所在行的非零元素的个数，入读为所在列的非零元素的个数，这个题注意下标是从零开始的。

如果G是一个有36条边的非连通无向图，那么该图顶点个数最少为多少？(3分)
A.7
B.8
C.9
D.10
D，考察完全连通图，知识点在上面不提，说解题思路，
设n=顶点数-1，则根据完全连通图可得n*(n-1)/2=36，解得n=9,顶点数=10；

设N个顶点E条边的图用邻接表存储，则求每个顶点入度的时间复杂度为： (2分)
A.O(N)
B.O(N​2​​)
C.O(N+E)
D.O(N×E)
C,在邻接表中，就是要依次访问每个顶点，然后在每个顶点中依次访问每条边，把这些边的终点的入度+1。也就是每个顶点和每条边依次要各访问一遍，所以时间复杂度是O(n+e)。

在任一有向图中，所有顶点的入度之和与所有顶点的出度之和的关系是： (1分)
A.相等
B.大于等于
C.小于等于
D.不确定
A.

在N个顶点的无向图中，所有顶点的度之和不会超过顶点数的多少倍？ (2分)
A.1
B.2
C.(N−1)/2
D.N−1
D，捋一捋关系，无向图中，边数最多是顶点数的n*(n-1)/2,而度数是边数的二倍

对于一个具有N个顶点的无向图，要连通所有顶点至少需要多少条边？ (2分)
A.N−1
B.N
C.N+1
D.N/2
A，注意区分

具有N（N>0）个顶点的无向图至多有多少个连通分量？ (2分)
A.0
B.1
C.N−1
D.N
D，一条边也没有

一个有N个顶点的强连通图至少有多少条边？ (2分)
A.N−1
B.N
C.N+1
D.N(N−1)
B，一个环就可以解决所有问题。

对于有向图，其邻接矩阵表示比邻接表表示更易于： (2分)
A.求一个顶点的入度
B.求一个顶点的出边邻接点
C.进行图的深度优先遍历
D.进行图的广度优先遍历
A

已知无向图G含有16条边，其中度为4的顶点个数为3，度为3的顶点个数为4，其他顶点的度均小于3。图G所含的顶点个数至少是：(4分)
A.10
B.11
C.13
D.15
B，16条边，32度，还剩8度，一个点最多两度，还能弄4个点。

图的广度优先遍历类似于二叉树的：(1分)
A.先序遍历
B.中序遍历
C.后序遍历
D.层次遍历
D，深度优先搜索DFS（Depth First Search）：访问方式类似于树的前序访问； 广度优先搜索BFS（Breadth First Search）：访问方式类似于树的从树根出发的按层次遍历。
同时也帮助对DFS,BFS的理解。

给定无向图G，从V0出发进行深度优先遍历访问的边集合为： {(V0,V1), (V0,V4), (V1,V2), (V1,V3), (V4,V5), (V5,V6)}。则下面哪条边不可能出现在G中？ (3分)
A.(V0,V2)
B.(V0,V6)
C.(V1,V5)
D.(V4,V6)
C，如果存在这条边的话在边的集合中会出现这条边。

如果无向图G必须进行两次广度优先搜索才能访问其所有顶点，则下列说法中不正确的是： (2分)
A.G肯定不是完全图
B.G中一定有回路
C.G一定不是连通图
D.G有2个连通分量
B附一篇百度百科，https://baike.baidu.com/item/%E8%BF%9E%E9%80%9A%E5%88%86%E9%87%8F/290350?fr=aladdin

下列说法不正确的是： (2分)
A.图的遍历是从给定的源点出发每一个顶点仅被访问一次
B.遍历的基本算法有两种：深度遍历和广度遍历
C.图的深度遍历是一个递归过程
D.图的深度遍历不适用于有向图
D，同样适用于

给定一有向图的邻接表如下。从顶点V1出发按广度优先搜索法进行遍历，则得到的一种顶点序列为： (2分)

A.V1,V2,V3,V4,V5
B.V1,V2,V3,V5,V4
C.V1,V3,V2,V4,V5
D.V1,V4,V3,V5,V2
C，注意是广度搜索！

关于最小生成树我们用两篇博客解决，
https://blog.csdn.net/weixin_42110638/article/details/84206658
看完这篇你可能一堆疑问，然后我们再看这一篇


在一个有权无向图中，若b到a的最短路径距离是12，且c到b之间存在一条权为2的边，则c到a的最短路径距离一定不小于10。
T，如果C->A小于10的话，B->A的最短路径就不是12了。

若要求在找到从S到其他顶点最短路的同时，还给出不同的最短路的条数，我们可以将Dijkstra算法略作修改，增加一个count[]数组：count[V]记录S到顶点V的最短路径有多少条。则count[V]应该被初始化为： (3分)
A.count[S]=1;对于其他顶点V则令count[V]=0
B.count[S]=0;对于其他顶点V则令count[V]=1
C.对所有顶点都有count[V]=1
D.对所有顶点都有count[V]=0
A.求有多少条最短路径，注意一点，整条路径中可能包含多条短的路径，而短的路径改变则算整个路径条数的改变，由递推式cout[v]=cout[v]+cout[p];

在AOE网中，什么是关键路径？ (1分)
A.最短回路
B.最长回路
C.从第一个事件到最后一个事件的最短路径
D.从第一个事件到最后一个事件的最长路径
D，因为必不可少所以最长

在拓扑排序算法中用堆栈和用队列产生的结果会不同吗？(1分)
A.是的肯定不同
B.肯定是相同的
C.有可能会不同
D.以上全不对
C,这个。。记住就行了吧，个人感觉其实都一样，蒟蒻的我

若将n个顶点e条弧的有向图采用邻接表存储，则拓扑排序算法的时间复杂度是：(1分)
A.O(n)
B.O(n+e)
C.O(n​2​​)
D.O(n×e)
B,只需要遍历一遍即可

对下图进行拓扑排序，可以得到不同的拓扑序列的个数是： (2分)
A.4
B.3
C.2
D.1
B,1.aebc 2.abced 3.abecd

已知有向图G=(V, E)，其中V = {v1, v2, v3, v4, v5, v6}，E = {<v1,v2>, <v1,v4>, <v2,v6>, <v3,v1>, <v3,v4>, <v4,v5>, <v5,v2>, <v5,v6>}。G的拓扑序列是： (2分)
A.v3, v1, v4, v5, v2, v6
B.v3, v4, v1, v5, v2, v6
C.v1, v3, v4, v5, v2, v6
D.v1, v4, v3, v5, v2, v6
A,附上一篇拓扑排序模板了解拓扑排序的工作原理https://blog.csdn.net/NCC__dapeng/article/details/82251973
再来一篇拓扑排序详解https://blog.csdn.net/lisonglisonglisong/article/details/45543451

插播一段AOV网关键路径的博客：https://mp.csdn.net/postedit/84552419
这是一道题目的解释，但在博客中会有具体知识点的介绍。

若二叉搜索树是有N个结点的完全二叉树，则不正确的说法是：(1分)
A.所有结点的平均查找效率是O(logN)
B.最小值一定在叶结点上
C.最大值一定在叶结点上
D.中位值结点在根结点或根的左子树上
C，注意这个题有点坑，他是个完全二叉树，这就说明，左子树节点的数量一定会大于等于右子树节点的数量，那么D，项就是正确的。A，二叉搜索树的平均查找效率，https://baike.baidu.com/item/%E4%BA%8C%E5%8F%89%E6%90%9C%E7%B4%A2%E6%A0%91/7077855?fr=aladdin相信这篇百度百科会给你详解，B,C考察的是完全二叉树最下面一层都集中在左边的特性，再根据二叉搜索树的性质，就不难得出答案。

下列二叉树中，可能成为折半查找判定树（不含外部结点）的是： (4分)
A.
B.
C.
D.
A，折半查找判定树，这个题主要考察他的建树要求，一篇博客，https://blog.csdn.net/u011240016/article/details/52923559 。

若一棵二叉树的前序遍历序列是{ 4, 2, 1, 3, 6, 5, 7 }，中序遍历序列是{ 1, 2, 3, 4, 5, 6, 7 }，则下列哪句是错的？(3分)
A.这是一棵完全二叉树
B.所有的奇数都在叶子结点上
C.这是一棵二叉搜索树
D.2是5的父结点
D，直接附上一篇博客，这个需要自己画图，图并不难画，这里不给出。
https://blog.csdn.net/NCC__dapeng/article/details/83830491

对二叉搜索树进行什么遍历可以得到从小到大的排序序列？ (1分)
A.前序遍历
B.后序遍历
C.中序遍历
D.层次遍历
C

下列叙述正确的是（）。 (2分)
A.在任意一棵非空二叉搜索树，删除某结点后又将其插入，则所得二叉搜索树与删除前原二叉搜索树相同。
B.二叉树中除叶结点外, 任一结点X，其左子树根结点的值小于该结点（X）的值；其右子树根结点的值≥该结点（X）的值，则此二叉树一定是二叉搜索树。
C.虽然给出关键字序列的顺序不一样，但依次生成的二叉搜索树却是一样的。
D.在二叉搜索树中插入一个新结点，总是插入到最下层，作为新的叶子结点。
D，https://blog.csdn.net/yanxiaolx/article/details/51986428 二叉搜索树详解

对一组包含10个元素的非递减有序序列，采用直接插入排序排成非递增序列，其可能的比较次数和移动次数分别是： (2分)
A.100, 100
B.100, 54
C.54, 63
D.45, 44
D.先来一篇关于插入排序的博客，https://blog.csdn.net/NCC__dapeng/article/details/85068075
加入我们需要把12345678910 变为 10987654321
先计算比较次数，从2开始为1，2，3，4。。。9，等差数列加和的出位45，
但是在计算交换次数时我们发现也应该是45，但答案却给出44，是因为我们忽略了，两个元素相等的情况！！！

用直接插入排序方法对下面四个序列进行排序（由小到大），元素比较次数最少的是（）。 (2分)
A.94,32,40,90,80,46,21,69
B.21,32,46,40,80,69,90,94
C.90,69,80,46,21,32,94,40
D.32,40,21,46,69,94,90,80
B，越有序比较次数越少，不懂得看一下插入排序的循环代码。
插播基于插入排序的希尔排序的算法详解：https://blog.csdn.net/daiyudong2020/article/details/52445044

希尔排序是稳定的算法。
F.https://baike.baidu.com/item/%E6%8E%92%E5%BA%8F%E7%AE%97%E6%B3%95%E7%A8%B3%E5%AE%9A%E6%80%A7/9763250?fr=aladdin

这里直接给出九种排序算法的稳定性。
对N个记录进行堆排序，需要的额外空间为O(N)。
F，1、 所有的简单排序方法（包括：直接插入、起泡和简单选择）和堆排序的空间复杂度为O(1)；

2、 快速排序为O(logn )，为栈所需的辅助空间；

3、 归并排序所需辅助空间最多，其空间复杂度为O(n )；

4、链式基数排序需附设队列首尾指针，则空间复杂度为O(rd )。
在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左右指针都会停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)
A.O(logN)
B.O(N)
C.O(NlogN)
D.O(N​2​​)
C

在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左右指针都不停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)
A.O(logN)
B.O(N)
C.O(NlogN)
D.O(N​2​​)
D

在快速排序的一趟划分过程中，当遇到与基准数相等的元素时，如果左指针停止移动，而右指针在同样情况下却不停止移动，那么当所有元素都相等时，算法的时间复杂度是多少？(2分)
A.O(logN)
B.O(N)
C.O(NlogN)
D.O(N​2​​)
D：上面三道题其实是一道题，https://www.cnblogs.com/dapeng-bupt/p/7922719.html，快速排序的最后最坏的情况分析。

对于7个数进行冒泡排序，需要进行的比较次数为： (2分)
A.7
B.14
C.21
D.49
C，首先你得知道冒泡排序的代码怎么写，这个应该都会，，，列个算式6*(1+6)/2=21;

有组记录的排序码为{ 46，79，56，38，40，84 }，则利用堆排序的方法建立的初始堆为： (2分)
A.79，46，56，38，40，80
B.84，79，56，46，40，38
C.84，56，79，40，46，38
D.84，79，56，38，40，46
D，堆的创建，没啥好说的还是一篇博客，https://blog.csdn.net/MoreWindows/article/details/6709644
强调一点，一定要去自己建立堆试一试，而不是光看就可以。

用递归方式对顺序表进行快速排序，下列关于递归次数的叙述中，正确的是： (2分)
A.每次划分后，先处理较长的分区可以减少递归次数
B.每次划分后，先处理较短的分区可以减少递归次数
C.递归次数与每次划分后得到的分区处理顺序无关
D.递归次数与初始数据的排列次序无关
C，原因参考上面的博客。

对于序列{ 49，38，65，97，76，13，27，50 }，按由小到大进行排序，下面哪一个是初始步长为4的希尔排序法第一趟的结果？ (2分)
A.13,27,38,49,50,65,76,97
B.49,13,27,50,76,38,65,97
C.49,76,65,13,27,50,97,38
D.97,76,65,50,49,38,27,13
B https://blog.csdn.net/daiyudong2020/article/details/52445044

对于10个数的简单选择排序，最坏情况下需要交换元素的次数为： (2分)
A.9
B.36
C.45
D.100
A，注意是交换次数，不是比较次数；

对N个记录进行堆排序，需要的额外空间为： (1分)
A.O(1)
B.O(logN)
C.O(N)
D.O(NlogN)
A.

对N个记录进行归并排序，归并趟数的数量级是O(NlogN)
F一篇归并排序详解https://blog.csdn.net/yuehailin/article/details/68961304 归并的趟数相当于二分的趟数

对N个记录进行归并排序，空间复杂度为： (1分)
A.O(logN)
B.O(N)
C.O(NlogN)
D.O(N​2​​)
B，
答案参考上面的博客。

给出关键字序列{ 431, 56, 57, 46, 28, 7, 331, 33, 24, 63 }，下面哪个选择是按次位优先（LSD）链式基数排序进行了一趟分配和收集的结果？ (2分)
A.→331→431→33→63→24→56→46→57→7→28
B.→56→28→431→331→33→24→46→57→63→7
C.→431→331→33→63→24→56→46→57→7→28
D.→57→46→28→7→33→24→63→56→431→331
C，https://blog.csdn.net/u011948899/article/details/78027838 基数排序，
LSD，最低位优先 MSD，最高位优先

数据序列{ 3, 1, 4, 11, 9, 16, 7, 28 }只能是下列哪种排序算法的两趟排序结果？(2分)
A.冒泡排序
B.快速排序
C.插入排序
D.堆排序
B，除了快速排序，其余的算法都是一步到位

对10TB的数据文件进行排序，应使用的方法是：(1分)
A.希尔排序
B.堆排序
C.归并排序
D.快速排序

C,网上查了博客看到的，对于10TB的海量数据，数据不可能一次全部载入内存，传统的排序方法就不适用了，需要用到外排序的方法。外排序采用分治思想，即先对数据分块，对块内数据进行排序，然后采用归并排序的思想进行排序，得到数据的一个有序序列。具体的思路建议可以查资料看一下。

在内部排序时，若选择了归并排序而没有选择插入排序，则可能的理由是：(2分)
1.归并排序的程序代码更短
2.归并排序占用的空间更少
3.归并排序的运行效率更高
A.仅 2
B.仅 3
C.仅 1、2
D.仅 1、3
B

下列排序方法中，若将顺序村吃更换为链式存储，则算法的时间效率会降低的是：(2分)
1.插入排序；2.选择排序；3.起泡排序；4.希尔排序；5.堆排序
A.仅1、2
B.仅2、3
C.仅3、4
D.仅4、5
D，那两个排序都要跳跃式访问节点。

{ 12，9，11，8，7，4，5，13，23 }是下列哪种方法第二趟排序后的结果？ (2分)
A.归并排序
B.堆排序
C.插入排序
D.基数排序
B，可能C会有问题，如果是C的话那么前三个应该是有序的，B项应该是最大堆的堆排序，每次把第一个跟最后一个交换。

将序列{ 2, 12, 16, 88, 5, 10, 34 }排序。若前2趟排序的结果如下：
第1趟排序后：2, 12, 16, 10, 5, 34, 88
第2趟排序后：2, 5, 10, 12, 16, 34, 88
则可能的排序算法是：(2分)
A.冒泡排序
B.快速排序
C.归并排序
D.插入排序
B，https://blog.csdn.net/guoweimelon/article/details/50902597 冒泡排序详解。

在对N个元素进行排序时，基于比较的算法中，其“最坏时间复杂度”中最好的是： (1分)
A.O(logN)
B.O(N)
C.O(NlogN)
D.O(N​2​​)
C，没记错的话应该是归并排序与堆排序，上面有提到

下列排序算法中，哪种算法可能出现：在最后一趟开始之前，所有的元素都不在其最终的位置上？（设待排元素个数N>2） (2分)
A.冒泡排序
B.插入排序
C.堆排序
D.快速排序
B，插入排序的特点就是，从前往后慢慢来，如果最后一个应该在第一位那么，所有的就都不在自己的位置上。这种题实在不会也可以用排除法慢慢的排除。

下列排序算法中，时间复杂度不受数据初始状态影响，恒为O(NlogN)的是： (1分)
A.冒泡排序
B.直接选择排序
C.堆排序
D.快速排序
C，堆排序的特点

排序方法中，从未排序序列中依次取出元素与已排序序列中的元素进行比较，将其放入已排序序列的正确位置的方法称为： (1分)
A.插入排序
B.选择排序
C.快速排序
D.归并排序
A