算法基础知识【4】（8-12）

Date: 2019-08-12

1.  算法的时间复杂度与空间复杂度没有直接关系  

因为：算法的时间复杂度是指执行算法所需要的计算工作量，可以用执行算法过程中所需基本运算的执行次数来度量；算法的空间复杂度是指执行这个算法所需要的内存空间。由此可知，算法的时间复杂度与空间复杂度并不相关

2.冒泡排序算法在非有序的序列中时间复杂度是？（）  O(n^2),在基本有序的情况下是o(n)

3.  线性表就是顺序存储的表()  错误的说法

解释：线性表可以分为顺序存储结构和链式存储结构，其中顺序存储结构的逻辑顺序和存储顺序是一致的；而链式存储的并不是一致的。

另外：线性结构与非线性结构，主要看元素之间的关系，如果是一对一的关系则是线性表，如果不是一对一的关系则是非线性表。如：树，图。栈和队列就是用线性结构实现的，它本身就是一中种结构。可以把栈和队列归在线性结构中 ，线性表自然是属于线性结构的。

4.  设有序顺序表中有n个数据元素，则利用二分查找法查找数据元素X的最多比较次数不超过（）。  一般情况是logn的向上取整，则一般化之后 就是O(logn)+1

5.  

用Prim算法求解下图以1为起始点的最小生成树的权值之和（17）
依次选择最小的边，往最生成树集中加边，使边数之和等于n-1，且是连通无环，则就构成了最小生成树

6.  int main(){fork()||fork();}共创建几个进程：_____  3个进程

牛客上的解释：

fork()给子进程返回一个零值，而给父进程返回一个非零值；

在main这个主进程中，首先执行 fork() || fork(), 左边的fork()返回一个非零值，根据||的短路原则，前面的表达式为真时，后面的表达式不执行，故包含main的这个主进程创建了一个子进程，

由于子进程会复制父进程，而且子进程会根据其返回值继续执行，就是说，在子进程中， fork() ||fork()这条语句左边表达式的返回值是0, 所以||右边的表达式要执行，这时在子进程中又创建了一个进程，

即main进程->子进程->子进程，一共创建了3个进程。

7.  已知待排序的n个元素可分为n/k个组,每个组包含k个元素,且任一组内的各元素均分别大于前一组内的所有元素和小于后一组内的所有元素,若采用基于比较的排序,其时间下界应为()O(nlogk)

解释：整体的k个组的元素是有序的，只是每个内部元素是无序的，内部元素的排序平均时间复杂度是O(klogk),然后一共有n/k个组，则整合后的时间复杂度是O(nlogk)

8.  假设包含t个非零元素的稀疏矩阵A含有m行n列，并采用三元组顺序表压缩存储，其快速转置算法的时间复杂度为（    ）

对于系数矩阵的三元组存储方法：首先最原始的时间复杂度是O(m*n),然后改进：基于每一行的初始位置，首先要计算行数，然后进行存储，这种情况需要O(m+n)；这里的算法是采用三元组顺序表压缩，转置算法的时间复杂度就是O（n+t）。

具体解释： 

快速转置：

1.初始化所有列的非零元素的个数统计为0（n）

2.统计每一列的非零元素个数（t）

3.接着求每一列第一个非零元素的首位置（n）

4.最后对每一个非零个数转置（t）。

总共时间：2*（n+t）

于是，时间复杂度：O（n+t）

9.  排序算法不稳定的有?  冒泡+归并+基数+插入排序法是稳定排序算法。  快速+选择+堆排序+希尔排序时不稳定算法！

part two 

1. 下列关于 排序算法中的说法中，错误的有（） D

A.在待排序的元素序列基本有序的前提下，效率最高的排序方法是插入排序 (补充：对于改进后的冒泡排序，其也是同样效率)

B. 堆排序的时间复杂度为O(nlogn)  （堆排序的时间复杂度与初始状态无关，恒定， 还有的是堆+归并+选择+基数）

C.关键字比较的次数与激励的初始排列次序无关的是冒泡排序  （冒泡是无关的，但是改进后的冒泡排序算法是有关的）

D. 快速排序是一种稳定的排序算法   【错，不稳定，稳定的有：冒，归 ，插，基】

解释：

• 对于选项A，插入排序原理每次从待插入组中取出一个元素，与有序组的元素进行比较，并找到合适的位置，将该元素插到有序组当中。所以有序元素越多，待排序的就相对越少，效率也就最高，所以A正确。
• 对于选项B，堆排序原理将待排序序列构造成一个大顶堆（小顶堆），整个序列的最大值（最小值）就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，重复操作。这种数据结构而设计的一种排序算法，堆排序是一种选择排序，其最坏，最好，平均时间复杂度均为O(nlogn)。所以B正确。
• 对于选项C，冒泡排序原理是相邻元素一次比较，不符条件的就交换位置，每一对相邻元素作同样的工作，所以和初始排序无关，C正确。
• 对于选项D，快速排序属于找一个基准值，将这个序列中所有比基准数大的数放在其右边，比基准数小的数放其左边。如果选择其中相同元素之一（且位置位于较后）作为基准值，而大于等于基准值元素放在基准值之后，那么本来位置位于较前的基准相同元素就会被调到基准值后，所以不稳定。D错误。

2.  排序算法的稳定性是指()经过排序之后,能使值相同的数据保持原顺序中的相对位置不变

3.  为实现快速排序算法，待排序序列宜采用的存储方式是链式存储。  错误，应该是顺序存储结构比较适合

解释：

1）链式存储不适用于需要随机读取的算法（链表无法进行随机读取，只能从头读到尾），可以用顺序存储的方式

2）待排序记录序列是线性结构，可以用顺序存储结构和链式存储结构表示。 对于顺序存储结构进行排序时，是对序列中的记录本身进行物理重排（通过关键字之间的比较判断，将记录移动到合适的位置）。 而对以链表作为存储结构的序列进行排序时，无序移动记录，仅需修改指针。

4.  查找n个元素的有序表时,最有效的查找方法是()  折半查找算法 > 分块查找 > 顺序查找

5.  快速排序的平均时间复杂度和最坏时间复杂度是?   O(nlgn) , O(n^2)

6.  为提高散列（Hash）表的查找效率，可以采取的正确措施是（仅Ⅱ、Ⅲ）。

Ⅰ．增大装填（载）因子      （解释：装载因子(表中记录数与表长之比)越大，表明越容易发生冲突或者溢出）

Ⅱ．设计冲突（碰撞）少的散列函数

Ⅲ．处理冲突（碰撞）时避免产生聚集（堆积）现象

解释：Hash表的查找效率取决于散列函数、处理冲突的方法和装填因子。显然，冲突的产生概率与装填因子（表中记录数与表长之比）的大小成正比，即装填得越满越容易发生冲突，Ⅰ错误。Ⅱ显然正确。采用合适的处理冲突的方式避免产生聚集现象，也将提高查找效率，例如用拉链法解决冲突时就不存在聚集现象，用线性探测法解决冲突时易引起聚集现象，Ⅲ正确。

7. 在待排序的记录集中，存在多个具有相同键值的记录，若经过排序，这些记录的相对次序仍然保持不变，称这种排序为稳定排序，这样的说法正确吗？ YES

8.  以下程序是用来计算两个非负数之间的最大公约数，我们假设x,y中最大的那个数的长度为n，基本运算时间复杂度为O(1)，那么该程序的时间复杂度为()：  O(logn)

long long gcd(long long x, long long y) { 
    if (y == 0) 
        return x; 
    else
        return gcd(y, x % y); 
}

牛客上的解释图：

9.  折半查找的时间复杂性为（）O(logn)

10. 

对数列(25,84,21,47,15,27,68,35,20)进行排序，元素序列的变化情况如下:

1. 25,84,21,47,15,27,68,35,20

2. 20,15,21,25,47,27,68,35,84

3. 15,20,21,25,35,27,47,68,84

4. 15,20,21,25,27,35,47,68,84 

答案：采用了快速排序法

11.  对长度为n的线性表排序，在最坏情况下，比较次数不是n(n-1)/2的排序方法是 D

A. 快速排序算法

B.冒泡排序法

C.直接插入法

D.堆排序

12.  关于排序算法的以下说法，错误的是______。D

A. 快速排序的平均时间复杂度为O（nlogn），最坏时间复杂度为O（n2）

B. 堆排序的平均时间复杂度为O（nlogn），最坏时间复杂度为O（nlogn）

C. 冒泡排序的平均时间复杂度为O（n2），最坏时间复杂度为O（n2）

D. 归并排序的平均时间复杂度为O（nlogn），最坏时间复杂度为O（n2） (最坏时间复杂度有问题，是恒定的)

13.  字符串通常采用的两种存储方式是？  顺序存储和链式存储结构

解释：  字符串的两种最基本的存储方式是顺序存储方式和链接存储方式,字符串或串(String)是由零个或多个字符组成的有限序列,它是编程语言中表示文本的数据类型。通常以串的整体作为操作对象。串的两种最基本的存储方式是顺序存储方式和链接存储方式。

14.  假设基准值为数组首元素的快速排序，要使得数组满足非降序排列，下列数据分布导致快排算法效率最低的是____。

答案：1-2-3-4-5-6-7

解释：对于快速排序最坏的情况是在基本有序的情况下，其的时间复杂度是O(n^2).需要进行非降序排列，则整个就应该是非降序

15.  二叉树为二叉排序树的充分必要条件是其任一结点的值均大于其左孩子的值、小于其右孩子的值，这样的说法正确吗？ 错误

如果将左孩子、右孩子换成左子树、右子树正确。

解释：二叉排序树（Binary Sort Tree）又称二叉查找树.它或者是一棵空树；或者是具有下列性质的二叉树：

（1）若左子树不空,则左子树上所有结点的值均小于它的根结点的值；

（2）若右子树不空,则右子树上所有结点的值均大于它的根结点的值；

（3）左、右子树也分别为二叉排序树

16. 用二分法查找长度为10的、排好序的线性表，查找不成功时，最多需要比较多少次？ 4次 (long+1)

17.  下列哪个排序算法是稳定的   冒 归 插 基

18.  下列排序算法中，某一趟结束后未必能选出一个元素放在其最终位置上的是（）。 D

A. 堆排序 (堆排序每趟总能选出一个最大值或者最小值位于根节点。)

B. 冒泡排序  (冒泡排序总是两两比较选出一个最小值位于数组前面。 )

C. 快速排序  (快排选出的枢轴在一趟排序中就位于了它最终的位置 )

D. 直接插入排序  (直接插入排序不一定会位于最终的位置，因为不确定后面插入的元素对于前面的元素是否产生影响。)

19.  为实现快速排序算法，待排序序列宜采用的存储方式是（）。   顺序存储

20.  下面关于查找算法的论述中哪个不是正确的？ A

A. 顺序查找需要查找表为有序表

B. 折半查找需要查找表为有序表

C. 查找表可分为静态查找表和动态查找表

D. 动态查找表的特点是表结构本身在查找过程中动态生成的

21. 设顺序表的长度为n，则顺序查找的平均比较次数为（）。  （n+1）/2

解释：对于序列长度为n的列表进行顺序查找总共需要比较（n*(n+1)）/2次，但由于是计算的平均，所以除以n即是答案

22.  已知用某种排序方法对关键字序列（51，35，93，24，13，68，56，42，77）进行排序时，前两趟排序的结果为
（35，51，24，13，68，56，42，77，93）
（35，24，13，51，56，42，68，77，93）
所采用的排序方法是_________________  冒泡排序

23.  设有 1000 个基本有序的元素，希望用最快的速度挑选出其中前 10 个最大的元素，最后选用（ ）排序法。堆/冒泡

24.  下列叙述中错误的是（ ） A

A. 对于各种特定的输入,算法的时间复杂度是固定不变的

B. 算法的时间复杂度与使用的计算机系统无关

C. 算法的时间复杂度与使用的程序设计语言无关

D. 算法的时间复杂度与实现算法过程中的具体细节无关

解释：算法的时间复杂度是指执行算法所需要的计算工作量。为了能够比较客观地反映出一个算法的效率，在度量一个算法的工作量时，不仅应该与所使用的计算机、程序设计语言以及程序编制者无关，而且还应该与算法实现过程中的许多细节无关。为此，可以用算法在执行过程中所需基本运算的执行次数来度量算法的工作量。算法所执行的基本运算次数还与问题的规模有关；对应一个固定的规模，算法所执行的基本运算次数还可能与特定的输入有关。

25.  对记录（54,38,96,23,15,72,60,45,83）进行直接插入排序时，当把第八个记录45插入到有序表时，为找到插入位置需比较（）次  5

注意：在比较时，需要再往前走一步，确定大于前面的元素，小于后面的元素

26.  现有1G数据需要排序，计算资源只有1G内存可用，下列排序方法中最可能出现性能问题的是____。 归并排序

因为归并排序时目前所有基础排序算法中，占用内存空间最大的

27.  从n个数里面找最大的两个数理论最少需要比较   n+ logn -2  【多看】

解释： 

类似比赛晋级，两两配对比较，赢的再两两配对，最后得到冠军(最大的数)，可以看成是一棵二叉树，以4人为例：

                            0

                      0          2

                   0    1    2     3

可以看出，找出最大的数比较次数是n-1。然后第二大的数肯定是跟冠军比较过的数字，那么很明显每一层都有一个，所以有logn-1次比较。

 

所以总共是n+logn-2次比较

28.  

下面是折半查找的实现，data是按升序排列的数据，x是查找下标，y是查找的上标，

v是查找的数值，返回v在data的索引，若没找到返回-1。代码不正确是____。1，4，5

public int bsearch(int[] data, int x, int y, int v) {
    int m;
    while(x<y){ //1
        m = x + (y-x)/2; //2
        if(data[m] == v) return m; //3
        else if(data[m] > v) y = m; //4
        else x = m; //5
    }
    return -1; //6
}

补充应该是这样的：

while(x<=y) {  //1
        m = x + (y-x)/2; //2 
        if(data[m] == v) return m; //3 
        else if(data[m] > v) y = m-1; //4 
        else x = m+1; //5 
    } 

part three 

1. 算法的优劣与算法描述语言无关,但与所用计算机有关() 错误，与计算机无关

2. 采用折半查找法查找长度为 n 的线性表时，每个元素的平均查找长度为 。  O(logn)

3.  线性表的长度为10，在最坏情况下，冒泡排序需要比较次数为（） 。 45次    （n*(n-1)/2）；区分顺序查找的是（n*(n+1)/2）

4.  执行一趟快速排序能够得到的序列是（）。 A

A [41，12，34，45，27] 55 [72，63]

B [45，34，12，41] 55 [72，63，27]

C [63，12，34，45，27] 55 [41，72]

D [12，27，45，41] 55 [34，63，72]

主考查点在于：基础点左边的子序列都小于该数，右边得都大于该数

5.  在待排数据基本有序的情况下,快速排序效果最好()  错误，是最差的

6.  任何一个递归过程都可以转换成非递归过程()  正确  （任何递归都可以转化成非递归的过程，汉诺塔可以用循环和栈实现。 ）

7. 【初没会】 顺序表含有127个元素,向其插入一个新元素并保持原来顺序不变,平均要移动____个元素()   63.5

解释：题意要保持原顺序不变的话，就只有两种情况，第一，插入在第一个位置，其余的向后移，总共127次；第二，插入到最后一个位置，其余的数不需要移动，总共0次；故而，平均移动次数为，(127+0)/2=63.5

8.  已知数据表A中每个元素距其最终位置不远，为了节省时间，应该采取的算法是() B直接插入法

直接选择排序

直接插入排序

堆排序

快速排序

解释：因为每个数据里最终目标不远，说明数据基本有序，直接插入排序是数据越有序越快，最快时间复杂度可达到O(n)，选择排序无论何时都是O（n^2）, 快速排序越有序越慢，它要从后到前遍历找比基准小的，时间复杂度达到O(n),堆排序需要不断进行调整，时间复杂度为O(nlog2^n)

9.  若要求尽可能快地对序列进行稳定的排序,则应选()  又快又稳的是B归并排序

快速排序

归并排序

起泡排序

10. 下列哪种排序需要的附加存储开销最大（）   归并算法

11.  以下程序段，其中n为正整数,则最后一行的语句频度在最坏情况下是()  O(n^2),  实质上其就是一个冒泡排序

FOR i:=n-1 DOWNTO 1 
DO 
    FOR j:=1 TO i DO 
        IF A[j]>A[j+1] 
            THEN A[j]与A[j+1]对换;

12. 采用递归方式对顺序表进行快速排序。下列关于递归次数的叙述中，正确的是（）。 D

递归次数与初始数据的排列次序无关

每次划分后，先处理较长的分区可以减少递归次数

每次划分后，先处理较短的分区可以减少递归次数

递归次数与每次划分后得到的分区的处理顺序无关

解释：

快递排序的递归次数与元素的初始排列有关。如果每一次划分后分区比较平衡，则递归次数少；如果划分后分区不平衡，则递归次数多。但快速排序的递归次数与分区处理顺序无关，即先处理较长的分区或先处理较短的分区都不影响递归次数。

此外，可以形象地把快速排序的递归调用过程用一个二叉树描述，先处理较长或较短分区，可以想象为交换某一递归结点处的左右子树，这并不会影响树中的分支数。

13. 已知 10 个元素 (54,28,16,34,,73,62,95,60,26,43) ，按照依次插入的方法生成一棵二叉排序树，查找值为 62 的结点所需比较次数为（）   3次

解释：

构成排序二叉树需满足条件：做子树比根节点小，根节点比右子树节点小，递归下去也满足。上图就是排序之后的二叉树，明显查找62需要比较54，73，62，共3次

14.  当采用分快查找时，数据的组织方式为 (    )  数据分成若干块，每块内数据不必有序，但块间必须有序，每块内最大（或最小）的数据组成索引块

注意：三种静态查找算法的分析与比较：顺序、二分/折半、索引/分块查找

15.  对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较（ ）次？（采用从后往前比较） 5次 

16.  执行()操作时,需要使用队列做辅助存储空间— 广度优先搜索网是先进先出，需要队列辅助；而深度优先是先进后出，需要栈

17.  在执行某个排序算法过程中,出现了排序码朝着最终排序序列位置相反方向移动,则该算法是不稳定的() 错误的

两者没有关系

18.  串的朴素模式匹配算法，主要思想是对主串(S)的每一个字符作为子串(T)开头，与要匹配的字符串进行匹配。主串(S)的长度为n，要匹配的子串的长度为m，那么朴素模式匹配算法的最坏时间复杂度为：O((n-m＋1)*m)

可以举例说明：n=10, m=3

19.  任何有向图的结点都可以排成拓扑排序，而且拓扑序列不唯一。（ ）错误，应该是有向无环图

20.递归函数中的形参是（）  自动变量(有点类似局部变量)

解释：

首先要理解的是递归是借助栈来实现的，自动变量是存储在栈里面的，随着递归的进行，自动创建和销毁。

外部变量和静态变量存放在静态存储区。外部变量和静态变量是不能作为递归函数的参数的。那么有同学会问了，为什么呢？首先，如果可以，那还要这个参数干什么呢？直接函数内改变不就行了？其次，递归的过程中，会创建变量存放在栈顶，如果是静态变量，递归结束后是不会被销毁的，如果忘记了，那就会造成空间很大的浪费。想想是不是不合理呢？编译器会禁止这么用的。

最后，自动变量可以大体上等价于局部变量。但也不完全相同

21.  Base64、MD5、AES 均属于常见的加密算法（） 第一个不是，后两个都是加密算法

解释;

Base64是网络上最常见的用于传输8Bit字节码的编码方式之一，Base64就是一种基于64个可打印字符来表示二进制数据的方法.不是加密算法

MD5消息摘要算法（英语：MD5 Message-Digest Algorithm），一种被广泛使用的密码散列函数

高级加密标准（英语：Advanced Encryption Standard，缩写：AES），在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准 

22. 下列排序法中，每经过一次元素的交换会产生新的逆序的是（ ）A

快速排序

冒泡排序

简单插入排序

简单选择排序

解释：

产生新的逆序对，并不是说逆序对的数目发生改变。稳定的排序算法，每交换一次，逆序对的数目必然发生改变。

冒泡每交换一次，会减少一个逆序对，并不会产生新的逆序对。

简单插入排序，若插入到已排序序列的最后，则不会产生新的逆序对。

简单选择排序，每次将一个元素归位。无论由小到大归位，还是由大到小归位，都不会产生新的逆序对。

而快排，是跳跃式交换，必然会产生新的逆序对。

23.  【没懂】给定的一个长度为N的字符串str,查找长度为P(P<N)的字符串在str中的出现次数.下面的说法正确的是()D

不存在比最坏时间复杂度O(NP)好的算法

不存在比最坏时间复杂度O(N^2)好的算法

不存在比最坏时间复杂度O(P^2)好的算法

存在最坏时间复杂度为O(N+P)的算法

存在最坏时间复杂度为O(log(N+P))的算法

以上都不对

补充：

朴素匹配算法 时间复杂度O（(N-P+1)*P）

KMP匹配算法 时间复杂度为O（N+P）

24.  【重点】串′ababaaababaa′的next数组为() 011234223456

解释来自牛客：

     i       0    1    2    3    4    5   6   7    8   9   10  11

     s     a    b    a    b    a    a   a   b    a    b   a    a  

next[i]   -1   0    0   1     2    3   1   1    2    3   4    5

先计算前缀next[i]的值： （字符串匹配是 从头开始的 和 从尾开始的字符串进行匹配是否重复 ）

next[i]的值主要是看s[i]之前的字符串中重复的子串长度。next[0] = -1，定值。  

next[1]是看s[1]之前的字符串“a”中重复的子串长度为0，故next[1] = 0。

next[2]是看s[2]之前的字符串“ab”中重复的子串长度为0，故next[2] = 0。

next[3]是看s[3]之前的字符串"aba"中重复的子串长度，s[0]与s[2]重复，长度为1，故next[3] = 1。

next[4]是看s[4]之前的字符串"abab"中重复的子串长度，s[01]与s[23]重复，长度为2，故next[4] = 2。

next[5]是看s[5]之前的字符串"ababa"中重复的子串长度，s[012]与s[234]重复，长度为3，故next[5] = 3。

next[6]是看s[6]之前的字符串"ababaa"中重复的子串长度，s[0]与s[5]重复(因为多了一个a，无法找到长度为3的重复字符串，这只能是s[0]和s[5]重复)，长度为1，故next[6] = 1。

同样的，求next[7]和next[8]、next[9]、 next[10]、 next[11] 分别为1和2、3、4、5。

25.  下列叙述中错误的是（  ）。A

对于各种特定的输入,算法的时间复杂度是固定不变的

算法的时间复杂度与使用的计算机系统无关

算法的时间复杂度与使用的程序设计语言无关

算法的时间复杂度与实现算法过程中的具体细节无关

26.  有关选择排序的叙述中正确的是（ ）

每扫描一遍数组，只需要一次交换 ； 空间复杂度为O(1)

27.  算法一般都可以用哪几种控制结构组合而成？ 顺序+循环+判断  一般不采用递归，递归的时间复杂度较高。