话不多说开始，看题目。

选择题

*使用双向链表存储数据，其优点是可以。*

A.很方便的插入和删除数据

B.节约存储空间

C.很快回收储存空间

D.提高检索速度

解析：正确答案（D）

A:因为单链表在插入和删除后继节点和双链表是一样的，只有在插入删除前驱的时候才更简单

B.多分配一个指针，空间使用了更多

C.回收都是一样的

D.单链表只能从前往后，而双链表支持从前向后、从后向前，会有更快的检索速度。

本人答题的时候，挺简单的

*关于“字符串”的描述，错误的是（）。*

A.字符串的长度必须大于零

B.字符串可以连续存储，也可以链式存储

C.字符串是一种特殊的线性表

D.”空串”与“空白串”不是同一个含义

解析：正确答案（A）

A:字符串的长度可以是0；

D:空串是零个字符的串，它的长度为零。而空白串是指由一个或多个空格组成的串，它的长度为串中空格字符的个数。
string str1 = “”； //空字符串，str1.length() 等于 0，分配了一个内存空间
string str2 = null； //NULL，未分配内存
string str3 = “ “； //空格串， str2.length() 等于 1，分配了内存
B:定长顺序存储、动态数组存储、块链存储

本人答题的时候，由于概念不清楚，只能通过字面意思来猜测概念的意思，在空串与空白串之间产生误区；连续存储、链式存储分析不清。

*算法分析的两个主要方面是（）。*

B:空间复杂度和时间复杂性

这题完全就是概念题了，对于算法，博主比较薄弱，这一题凭借记忆选的。

*面相对象的语言具有继承性、多态性和（）*

封装性

这题也是概念，博主本人是写C写的比较多，C++方面接触的比较少，对于这一类的问题，只能凭记忆选。

*小明、小华和小宝站成一排。小明是其中最大的，他只说真话；第二大的是小华，他只说假话；而最早的小宝有时说真话，有时说假话。小天知道这三个人，但不清楚到底哪个是哪个。他问最左边的这位“你们仨中间的是谁”？回答是“哦，那是小明”。小天随后问中间的这位，“你叫什么”？回答是“我是小宝”。最后小天问最右侧的那位“中间这位是谁”？他得到的回复是“是小华”。那么，这三位的排位顺序从左至右可能是。*

A:小宝小明小华

B:小明小宝小华

C:小宝小华小明

D:小明小华小宝

E:小华小宝小明

解析：正确答案(C)

首先假设最左边的是小明，由于他只能说实话，他说中间的是小明，这显然矛盾了，所以假设不成立；

再次假设最左边的是小华，由于他只能说假话，他说中间的是小明，所以小明只能在最右边，中间的应该是小宝。但小明说中间的是小华，这与推论结果冲突；

最后假设最左边的是小宝，

1.假设他说的是真的，中间的是小明，则最右边的是小华。而小明说中间是自己叫小宝，这也矛盾了；

2.假设他说的是假的，则中间应该是小华，最右边应该是小明，正好与题意相符；

*考察了计算题——曲线的拐点问题*

题目一

*若一组记录的排序码值序列为{50,80,30,40,70,60}利用快速排序方法,以第一个记录为基准,得到一趟快速排序的结果为( )*

解题方式：【又快又准做对考研真题】一组记录的关键字为(46， 79， 56， 38， 40， 84)，则利用快速排序的方法，以第一个记录为基准得到的一次划分结果为( )。_哔哩哔哩_bilibili

https://blog.csdn.net/weixin_69519040/article/details/127147161

代码方面：

#include <stdio.h>
 
void swap(int a[], int low, int high) //交换两个数的值
{
    int t = a[low];
    a[low] = a[high];
    a[high] = t;
}
 
int partition(int a[], int low, int high)  //计算基准点，分割为左右两个数组
{
    int point = a[low];//基准点等于第一个元素
/*    while(1){
        while(low<high && a[++low]<point);
        while(a[--high]>point);
        if(low>=high) break;
*/
      while(low<high)
      {
          while(low<high && a[high]>=point)//控制high指针比较并左移
          {
                 high--;
          }  
         swap(a,low,high);
              //}
         while(low<high && a[low]<=point)//控制low指针比较并右移
          {
                low++;
          }  
          swap(a,low,high);
      }
    return low;//返回基准点位置
}
 
void quicksort(int a[], int low, int high)  //low:起始位置 high:末尾位置
{
	


int i;
    if(low<high){
        int point = partition(a,low,high);//计算基准点
 for(i=0; i<6; i++) printf("%d ", a[i]);
		 printf("\n");
        quicksort(a,low,point-1);  //对基准点的左边进行排序

        quicksort(a,point+1,high);//对基准点的右边进行排序

    }
}
    
int main()
{
    int i;
    int a[] = {50,80,30,40,70,60};
    int N = 6;
    
    quicksort(a, 0, N-1);
    
    for(i=0; i<N; i++) printf("%d ", a[i]);
    printf("\n");
    
    return 0;
}

本人在写的时候时候，一点都不知道，在结束后，写博客的时候才明白怎么处理这个问题。

*设系统中有一类独占性共享资源数量为M，有N 个竞争该类资源的进程，各进程对资源的最大需
求量相同且为W。则以下M、N、W 的取值情况中，系统可能发生死锁的是（）。*

A:M=2, N=2, W=2

B:M=3, N=2, W=2

C:M=3, N=2, W=3

D:M=5, N=3, W=2

E:M=6,N=3,W=3

解析：正确答案（A、C、E）

N个进程各获得(W-1)个资源，且系统中没有资源剩下时，可能发生死锁。所以满足N×(W-1)≥M的情况即有可能发生死锁。

保证系统不会发生死锁的最小M值为：M=N(W-1)+1。

本人在答题的一头雾水，完全不知道这个是什么问题。

填空题

类可以转换成任意类型，且是所有类型的基类？

类型转换关键字用于将一个数据类型转换为另一个数据类型。C++ 中提供了四种类型转换关键字：static_cast、dynamic_cast、const_cast、reinterpret_cast。

在c或者c++中，可以指向任意类型的关键字就是无符号类型void，任何一个对象都可以使用void来指向

*栈和队列的相同点和不同点*

栈（Stack）和队列（Queue）是两种操作受限的线性表。
线性表：线性表是一种线性结构，它是一个含有n≥0个结点的有限序列，同一个线性表中的数据元素数据类型相同并且满足“一对一”的逻辑关系。
“一对一”的逻辑关系指的是对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个终端结点没有后继但有一个前驱结点，其它的结点都有且仅有一个前驱和一个后继结点。）

这种受限表现在：栈的插入和删除操作只允许在表的尾端进行（在栈中成为“栈顶”），满足“FIFO：First In Last Out”；队列只允许在表尾插入数据元素，在表头删除数据元素,满足“First In First Out”。

栈与队列的相同点：

1.都是线性结构。

2.插入操作都是限定在表尾进行。

3.都可以通过顺序结构和链式结构实现。、

4.插入与删除的时间复杂度都是O（1），在空间复杂度上两者也一样。

5.多链栈和多链队列的管理模式可以相同。

栈与队列的不同点：

1.删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。

2.应用场景不同；常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。

3.顺序栈能够实现多栈空间共享，而顺序队列不能。

*fat32文件系统最大单一档案大小为*

4GB

 NTFS（Windows）：支持最大分区2TB，最大文件2TB；

 FAT16（Windows）：支持最大分区2GB，最大文件2GB；

 FAT32（Windows）：支持最大分区128GB，最大文件4GB；

 HPFS（OS/2）：支持最大分区2TB，最大文件2GB；

 EXT2和EXT3（Linux）：支持最大分区4TB，最大文件2GB；

 JFS（AIX）：支持最大分区4P（block size=4k），最大文件4P；

 XFS（IRIX）：这是个正经的64位的文件系统，可以支持9E（2的63次方）的分区；

编程题

*求俩个数最大公约数*

思路：
1.将两整数求余 a%b = c
2.如果c = 0;则b为最大公约数
3.如果c != 0,则 a = b；b = c；继续从1开始执行
4.也就是说该循环的是否继续的判断条件就是c是否为0

举例说明：

a = 21 b = 28

c = a%b = 21%28 = 21，则c = 21 此时c不为0
执行 a = b ， b = c ， a = 28 ，b = 21

c = a%b = 28%21 = 7 ，则c = 7 此时c不为0
执行 a = b ， b = c ， a = 21 , b = 7

c = a%b = 21%47 = 0 ，则c = 0 循环结束

最大公约数：指某几个整数共有约数中最大的一个

#include <stdio.h>
int main()
{
    int a = 0;
    int b = 0;
    int c = 0;
    while(1)
    {   
        printf("输入两个数求最大公约数: ");
        scanf("%d%d",&a,&b);
        c = a%b;
        while(c)
        {
            a = b;
            b = c;
            c = a%b;
        }
        printf("最大公约数为： %d\n",b);
    }
    return 0;
}

*冒泡排序法*

#include <stdio.h>
void bubble_sort(int arr[], int len) {
        int i, j, temp;
        for (i = 0; i < len - 1; i++)
                for (j = 0; j < len - 1 - i; j++)
                        if (arr[j] > arr[j + 1]) {
                                temp = arr[j];
                                arr[j] = arr[j + 1];
                                arr[j + 1] = temp;
                        }
}
int main() {
        int arr[] = { 22, 34, 3, 32, 82, 55, 89, 50, 37, 5, 64, 35, 9, 70 };
        int len = (int) sizeof(arr) / sizeof(*arr);
        bubble_sort(arr, len);
        int i;
        for (i = 0; i < len; i++)
                printf("%d ", arr[i]);
        return 0;
}

逻辑题

*分析芝诺悖论*

在历史的进程中，科学家们提出了量子这一概念。而量子就是破解这个悖论的关键。我们刚才说，关键点在于时间和距离，只要时间和距离不是无限分割下去的，我们就可以终结这场赛跑。

量子理论则认为时间和长度并不可以无限拆分，普朗克时间和普朗克长度都是给出了最小的量度。普朗克时间为10^-43 秒，普朗克长度为1.6 x 10^-35 米。虽然这两个量度确实非常小，但是至少给出了一个极限。当然这是算有意义的量度，不然极限不应该被限制。

如果用微积分的角度来看，也可得出芝诺悖论的错误之处，当两者距离趋于0时，就可以将0代入求值，也就是乌龟和兔子将处于同一位置，可惜他们在此不会停止，将继续奔跑比赛，所以兔子必定超过乌龟。

简答题

*芯片检测题*

芯片测试：有2k块芯片，已知好芯片比坏芯片多．请设计算法从其中找出一片
好芯片，说明你所用的比较次数上限．
其中：好芯片和其它芯片比较时，能正确给出另一块芯片是好还是坏．

解答：

在任意偶数多的芯片里，如果好芯片多于坏芯片，将所有芯片两两分组，根据抽屉原理，
则有
1）必有两个好芯片分在一组。
2）同为好芯片的组数一定多于同为坏芯片的组数。

测试流程
1）将芯片两两分组，比如1和2，3和4。。。。2k-1和2k。互相测试，则必有结果同为真的
组。
2）保留结果同为真的组，丢弃其他组。必有好芯片组多于坏芯片组。（所以当只有两组或
者一组同为真时，则必为真，测试结束）
3）结果同为真的组芯片必定同好或者同坏，所以可以丢弃一半。从所有同真组中任意取出
一个丢弃另一个，组成新的测试组，继续两两分组，直到同真组只有2个或者1个测试结束
，坚持到最后的就是好芯片。

说明：同真组可能会变成奇数个，当为奇数组时，任意选一组取其中一个（假设为A），在
剩余组中各取一个来测试A，如果测试结果A为好芯片过半或者等于一半，则A为好芯片，测
试结束。否则A为坏芯片，判定A为好芯片的必为坏芯片，剔除后剩余部分形成新的测试组
，继续两两分组。。。

总的原理和淘金差不多，刚开始好的芯片多，在每次剔除芯片时一定要保证剔除的坏芯片
数量一定要多于或者等于好芯片的数量，这样就能保证在剩余的芯片中好的一定多于坏的
。当组数为奇数时采用投票制，多于半数的投票有效（等于也有效，因为好的多于坏的，
相等则被测试的一定为好的）。

因为每次最少剔除一半的芯片，所以最坏情况出现在每次只能剔除一半芯片的时候，按等
比数列递减。当有N个芯片时，测试次数为n+(n/2)+(n/4)…=2n
答题完毕.

*蚂蚁过桥题*

已知一只蚂蚁过桥的时间是1小时，现在你是蚂蚁军团的老大，如何使用蚂蚁计时1小时15分钟？

这题还未找到解法，后续补充上去。

*项目问题*

项目即将提测，自测过程中出现Bug，并且短时间内无法解决，这时应该怎么办？

解答：

项目提测的时候，发现Bug,此时应该及时汇报项目组长，并且把产生问题的原因、如何解决、花费多少时间等信心具体分析出来，一同上报。这类情况下，存在轻重缓急的区别，轻度则，不影响正常的提测，待提测后，进行处理；重则影响提测，需要上级安排人手，集中处理。

*谁的成绩好*

玲玲和芳芳经常在一起玩，有一次，有人问她们：“你们俩经常在一起玩，这次期末考试你们谁的成绩好呀？”玲玲说：“我的成绩比较好一点。”芳芳说：“我的成绩比较差一些。”
她们这两个人之中至少有一个人没有说实话。那么，到底她们谁的考试成绩好？

解答：

类推1.如果玲玲说谎，则芳芳成绩好，那么芳芳也说谎（两人都说谎）
类推2.如果玲玲没说谎，那么玲玲成绩好，那么芳芳也没有说谎（直接排除没人说谎）
类推3.如果芳芳说谎，那么芳芳成绩好，故玲玲也说了谎（两人都说谎）
综上所述只有类推1和类推三符合题意至少有一个人说谎，而且最终都指向芳芳成绩好。
所以最终答案玲玲芳芳都说了谎，芳芳成绩好。