笔试强训48天——day19

news2024/11/24 17:43:33

文章目录

一. 单选
- 1.二分查找的时间复杂度（）
- 2. 有一个单向链表中有一个A、B两个相邻元素，有一个指针p指向元素A，现将一个指针r指向的S元素要插入
- 3. 双向链表中有两个指针域,llink和rlink分别指向前驱和后继,设p指向链表中的一个结点,现要求删去p所指结
- 4.一个栈的入栈序列是A,B,C,D,E,则栈的不可能输出序列是（）
- 5.循环队列放在一维数组A[0…M-1]中，end1指向队头元素，end2指向队尾元素的后一个位置。假设队列两端
- 6. 已知二叉树后序遍历序列是bfegcda，中序遍历序列是badefcg，它的前序遍历序列是（）
- 7.某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）
- 8. 以下序列不是堆的是（）
- 10. 以下哪种排序是不稳定排序（）
二. 编程
- 1.汽水瓶
- 2. 查找两个字符串a,b中的最长公共子串

一. 单选

1.二分查找的时间复杂度（）

A O(N*log(N))
B O(N)
C O(log(N))
D O(N^2)

正确答案：C

前提：数据有序
2^n = x 对数间

2. 有一个单向链表中有一个A、B两个相邻元素，有一个指针p指向元素A，现将一个指针r指向的S元素要插入

到A和B之间，该进行操作（）
A p->next=p->next->next——删除
B r-next=p;p->next=r->next——p之前插入
C r->next=p->next;p->next=r
D r=p->next;->next=r->next
E r->next=p;p->next=r
F p=p->next->next

正确答案：C

3. 双向链表中有两个指针域,llink和rlink分别指向前驱和后继,设p指向链表中的一个结点,现要求删去p所指结

点,则正确的删除是()(链中结点数大于2,p不是第一个结点)
A p->llink->rlink:=p->llink; p->llink->rlink:=p->rlink; dispose§;
B dispose§; p->llink->rlink:=p->llink; p->llink->rlink:=p->rlink;
C p->link->rlink:=p->llink; dispose§; p->llink->rlink:=p->rlink;
D 以上A,B,C都不对

正确答案：D

根据题意，排除修改头指针的情况
p->rlink->llink = p->llink;
p->llink->elink = p->rlink;
之后再释放指针，delete（p）

4.一个栈的入栈序列是A,B,C,D,E,则栈的不可能输出序列是（）

A EDCBA
B DECBA
C DCEAB——只能是BA
D ABCDE

正确答案：C

5.循环队列放在一维数组A[0…M-1]中，end1指向队头元素，end2指向队尾元素的后一个位置。假设队列两端

均可进行入队和出队操作，队列中最多能容纳M-1个元素。初始时为空，下列判断队空和队满的条件中，正
确的是（）

A 队空：end1end2；队满：end1(end2+1) mod M
B 队空：end1end2；队满：end2(end1+1) mod (M-1)
C 队空：end2==(end1+1) mod M；队满：end1==(end2+1) mod M
D 队空：end1==(end2+1) mod M；队满：end2==(end1+1) mod (M-1)
正确答案：A

mod取模

6. 已知二叉树后序遍历序列是bfegcda，中序遍历序列是badefcg，它的前序遍历序列是（）

A abcdefg
B abdcefg
C adbcfeg
D abecdfg

正确答案：B

做这种题目是有技巧的，无论是前序和中序，还是后序和中序
区别就是：前序找第一个为根结点，后序找最后一个为根结点，中序用来划分左右子树
找到根结点之后去中序中观察顺序，在跟结点左边的就是左子树，在根节点右边的就是右子树

后序遍历序列是bfegcda：a是根
中序遍历序列是badefcg
在中序遍历中找到a，只有b在a的右边证明a的左子树只有b一个结点
中：defcg 前：fegcd——d为根结点 ——efcg全是右子树
中：efcg 前：fegc—c为根结点——ef是左子树，g是右子树
中：ef 前：fe——e为根结点——f为右子树

前序：根左子树右子树
abdcefg

7.某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）

A 不存在这样的二叉树
B 200
C 198
D 199

正确答案：B

二叉树的性质：对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为 n2,则有 n0＝n2 ＋1
度为0的比度为2的永远多一个（任何二叉树都满足）
199+1

8. 以下序列不是堆的是（）

A (100,85,98,77,80,60,82,40,20,10,66)
B (100,98,85,82,80,77,66,60,40,20,10)
C (10,20,40,60,66,77,80,82,85,98,100)
D (100,85,40,77,80,60,66,98,82,10,20)
正确答案：D

将每一个构造出来看看是否满足堆的构造
大堆：都小于根结点
小堆：都大于根结点

设有一组记录的关键字为{19,14,23,1,68,20,84,27,55,11,10,79}，用链地址法构造哈希表,哈希函数为
H(key)=key MOD 13，哈希地址为1的链中有（）个记录
A 1
B 2
C 3
D 4

正确答案：D

key%13 == 1
14 1 27 79

10. 以下哪种排序是不稳定排序（）

A 冒泡
B 插入排序
C 归并排序
D 快速排序
正确答案：D

排序效率好的——不稳定

二. 编程

1.汽水瓶

链接

某商店规定：三个空汽水瓶可以换一瓶汽水，允许向老板借空汽水瓶（但是必须要归还）。
小张手上有n个空汽水瓶，她想知道自己最多可以喝到多少瓶汽水。

数据范围：输入的正整数满足
注意：本题存在多组输入。输入的 0 表示输入结束，并不用输出结果。

输入描述：
输入文件最多包含 10 组测试数据，每个数据占一行，仅包含一个正整数 n（ 1<=n<=100 ），表示小张手
上的空汽水瓶数。n=0 表示输入结束，你的程序不应当处理这一行。
输出描述：
对于每组测试数据，输出一行，表示最多可以喝的汽水瓶数。如果一瓶也喝不到，输出0。

示例1:
输入
3 1
0
81
0
输出
15
40
说明
样例 1 解释：用三个空瓶换一瓶汽水，剩一个空瓶无法继续交换
样例 2 解释：用九个空瓶换三瓶汽水，剩四个空瓶再用三个空瓶换一瓶汽水，剩两个空瓶，向老板借一个空
瓶再用三个空瓶换一瓶汽水喝完得一个空瓶还给老板

正确答案：

#include<iostream>
using namespace std;

//概念法
int calcNumber_1(int n)
{
int sum = 0;
while(n > 1)
{
int res = n / 3; //所能兑换的个数
int left = n % 3; //遗下的个数
sum += res;
n = left + res;
if(n == 2)
{
sum++;
break;
}
} r
eturn sum;
}

//取巧法
int calcNumber_2(int n)
{
return n / 2;
}

int main()
{
    int n,res;
    while(cin>>n)
    {
        if(n == 0)
        break;   
        res =  calcNumber_1(n);
        cout<<res<<endl;
    }
    return 0;
}

2. 查找两个字符串a,b中的最长公共子串

链接

查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分
开！

数据范围：字符串长度

输入描述：
输入两个字符串
输出描述：
返回重复出现的字符

示例1:
输入
abcdefghijklmnop
abcsafjklmnopqrstuvw
输出
jklmnop

正确答案：

#include<iostream>
#include<string>
#include<vector>
using namespace std;

string Getstr(string &s1,string &s2)
{
    if(s1.size()>s2.size())
    swap(s1,s2);
    
    int l1 = s1.size();
    int l2 = s2.size();
    
    vector<vector<int>> a(l1+1,vector<int>(l2+1,0));
    
    int start = 0,max = 0;
    
    for(int i = 1;i<=l1;i++)
    {
        for(int j = 1;j<=l2;j++)
        {
            if(s2[j-1] == s1[i-1])
            a[i][j] = a[i-1][j-1]+1;
            
                    if(a[i][j]>max)
                    {
                        max = a[i][j];
                        start = i-max;                    
                    }        
        }    
    }
    return s1.substr(start,max);
}

int main()
{
    string s1,s2;
    while(cin>>s1>>s2)
    {
        string substr = Getstr(s1,s2);
        cout<<substr<<endl;    
    }
    return 0;
}