C语言/C++/数据结构牛客网刷题20200304

超、凢脫俗 2022-11-05 08:37 35阅读 0赞

# C语言 #

### 有数组定义int a\[2\]\[2\]=\{ \{1\},\{2,3\}\};则a\[0\]\[1\]的值为0。 ###

*  正确
 *  错误

正确答案: A   你的答案: B (错误)

未定义的数组成员默认为0

### 定义输入文件流对象fin方法是:ofstream fin;  这句话是否正确？ ###

*  正确
 *  错误

正确答案: B   你的答案: B (正确)

输入为ifstream（也就是in file stream），输出为ofstream（out file stream）

### 以下所列的 C 语言常量中，错误的是（）。 ###

*  0xFF
 *  1.2e0.5
 *  2L
 *  '\\72'

正确答案: B   你的答案: C (错误)

*  B：1.2e0.5   e后面要求是整数
 *  C: 表示这个2在内存中占用一个long型长度的空间
 *  D: '\\72'代表合法的一个字符常量，\\为转义字符，代表八进制，ascii码为8\*7 + 2= 58；58这个ASCII，即':'这个字符

### \*p++ 自增p 还是 p 所指向的变量? ###

*  先自增p
 *  先自增p所指向的变量
 *  和机器相关

正确答案: A   你的答案: B (错误)

后缀++ 和-- 操作符本质上比前缀一目操作的优先级高, 因此\*p++ 和\*(p++) 等价, 它自增p 并返回p 自增之前所指向的值。  
要自增p 指向的值, 使用(\*p)++, 如果副作用的顺序无关紧要也可以使用++\*p。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70][]

下面代码在32位计算机中输出的结果是（ ）

struct TEST_TYPE
    {
    int a;
    int b;
    };
    int testSize(struct TEST_TYPE val[10])
    {
    return sizeof(val);
    }

*  4
 *  8
 *  10
 *  80

正确答案: A   你的答案: D (错误)

子函数中传递的数组被当成指针对待，sizeof()以后只是一个指针的大小

### 下面说法正确的是： ###

*  函数的出口应该尽可能少，最好只有一个出口
 *  为了防止程序中内存漏，应该不使用动态分配内存
 *  在函数实现中应该少使用全局变量
 *  函数的功能应该单一

正确答案: C D   你的答案: A C D (错误)

A答案，应该提供多个出口，比如函数中设置多个if判断句，如果if不成立，后面的程序就没有必要执行下去了，就直接在if中return了，最后在函数的结尾出经常有一个return 0；这应该就是多个出口把

此题应该为多选题,函数最好要提供多个出口,如果是一个出口,那么可能死循环或者什么就出不来了,B明显错误,但是我们也应该小心的使用动态分配内存,于是有了智能指针, CD都无错误,所以答案为CD

### 以下程序运行后的输出结果是（      ） ###

int main()
    {
    int a=1,b=2,m=0,n=0,k;
    
    k=(n=b<a)&&(m=a) ;
    printf("%d,%d\n",k,m);
    
    return 0;
    }

*  0,0
 *  0,1
 *  1,0
 *  1,1

正确答案: A   你的答案: B (错误)

第一个正常算出来，前面的是false没毛病了，然后第二个的话，切记**&&是短路运算**，如果前面的为false的话，后面的不会执行和赋值的，所以m还是0

### 以下叙述中正确的是（） ###

*  逻辑"或"（即运算符||）的运算级别比算术运算要高
 *  C语言的关系表达式：0<x<10完全等价于: (0<x) && (x<10)
 *  逻辑"非"（即运算符!）的运算级别是最低的
 *  由&&构成的逻辑表达式与由||构成的逻辑表达式都有"短路"现象

正确答案: D   你的答案: A (错误)

0 < x < 10执行顺序：先执行0 < x 是否为真，返回值为0或1（假定为y）；在执行 y < 10判断是否为真。0 < x < 10不管0 < x 的为真还是为假，(0<x)的返回值不是0就是1，它们都小于10，所以永远为真。

短路效应是指，二元逻辑运算符&& ||，左边真值一旦确定，不会执行右边表达式，如if(true || printf("不执行))

### 下列运算符中优先级最高的是（）。 ###

*  <
 *  \+
 *  &&
 *  !=

正确答案: B   你的答案: C (错误)

**淡云一笔，鞍落三服**

**(单目)(算术)(移位)(比较),(按位)(逻辑)(三目)(赋值)**

这道题很简单，不用记优先级也可以推测出来：

if(a+b < c && d !=e )\{\}

不用括号也可以实现想要的判断，说明&&优先级最低，而且优先级：+高于<高于&&；

通过if(a+b != c)可以知道，+优先级高于!=。

### 若使用数组作函数实参，则以下正确的说法是（）。 ###

*  必须在主调函数中说明此数组的大小
 *  实参数组类型与形参数组类型可以不匹配
 *  在被调用函数中，不需要考虑形参数组的大小
 *  实参数组名与形参数组名必须一致

正确答案: C   你的答案: A (错误)

A选项：必须在主调函数中说明此数组的大小，不一定，例如传递一个char类型的字符串，就不需要。所以A是错的。

B选项：实参数组类型与形参数组类型可以不匹配。实参和形参，类型顺序必须一致，不然调用不了。B错

C选项：在被调用函数中，不需要考虑形参数组的大小。因为传数组都是只传一个地址过来，而如果函数的参数是指针类型变量,在调用该函数的过程中，传给函数的是实参的地址，在函数体内部使用的也是实参的地址，即使用的就是实参本身。所以在函数体内部可以改变实参的值。本选项说是不考虑形参数组的大小是对的。

D选项：实参数组名与形参数组名必须一致，明显错误。

### 以下叙述中不正确的是（）。 ###

*  一个好的程序应该有详尽的注释
 *  在 C 程序中，赋值运算符的优先级最低
 *  在 C 程序中，j++;是一条赋值语句
 *  C程序中的\#include和\#define均不是C语句

正确答案: B   你的答案: D (错误)

关于运算符优先级的题错了好多。所以查了一下资料，和大家分享一下：

一共有十五个优先级：  
1   ()  \[\]  .  ->  
2   !  ~   -（负号） ++  --   &（取变量地址）\*   （type）(强制类型)    sizeof  
3   \* / %  
4   + -  
5   >> <<  
6   > >= < <=  
7   == !=  
8   &  
9   ^  
10  |  
11  &&  
12  ||  
13  ?:  
14   =  +=  -=  \*=  /=   %=  |=   ^=   &=   >>=   <<=  
15  ,  
就着多吧   结合性：2   13  14  是从右至左   其他都是  从左至右有问题可以在交流的

口诀为

括号成员第一;        //括号运算符\[\]() 成员运算符.  ->  
全体单目第二;        //所有的单目运算符比如++、 --、 +(正)、 -(负) 、指针运算\*、&

乘除余三,加减四;   //这个"余"是指取余运算即%  
移位五，关系六;    //移位运算符：<< >> ，关系：> < >= <= 等  
等于(与)不等排第七;    //即== 和!=  
位与异或和位或，"三分天下"\*\*\*十;    //这几个都是位运算: 位与(&)异或(^)位或(|)  
逻辑或跟与，十二和十一;            //逻辑运算符:|| 和 &&，注意顺序:优先级(||)  低于 优先级(&&)  
条件高于赋值,        //三目运算符优先级排到13 位只比赋值运算符和","高  
逗号运算级最低!    //逗号运算符优先级最低

**D是对的，用分号;结尾的才看成是C语句**  
\#include和\#define并不参加编译，只是由预处理器来处理  
其中，\#include <file> 由预处理器负责将file引入的内容引入当前文件中，只是做简单的展开。  
\#define A B 只是将文件中出现A的地方简单的用B来替换。

# C++ #

### 能够从输入流中提取指定长度的字节序列的函数是（  ）。 ###

*  get
 *  getline
 *  read
 *  cin

正确答案: C   你的答案: A (错误)

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70 1][]

### 调用以下函数，将返回 ###

public static int func()
    {
        try
        {
            return 1;
        }
        catch (Exception e)
        {
            return 2;
        } finally
        {
            return 3;
        }
    }

*  1
 *  2
 *  3
 *  编译错误

正确答案: C   你的答案: C (正确)

当程序执行到try语句块中的return方法时，它会干这么一件事，将要返回的结果存储到一个临时栈中，然后程序不会立即返回，而是去执行finally语句块中的程序.

返回3， finally语句块会在return语句执行之前执行，所以由于catch块中直接执行的是return语句，那么finally代码块会先执行，由于finally块里只有一句return语句，于是执行的返回语句是return 3

### 设x、y、t均为int型变量，则执行语句：t=3; x=y=2; t=x++||++y; 后，变量t和y的值分别为\_\_\_\_ ###

*  t=1 y=2
 *  t=1 y=3
 *  t=2 y=2
 *  t=2 y=3
 *  t=3 y=2
 *  t=3 y=3

正确答案: A   你的答案: B (错误)

此题考点为运算符的优先级,自增运算符、短路运算、赋值运算符的优先级。

按照优先级原则来说：

t=x++||++y;  先执行 x++ 然后执行||,最后执行=。

由于x=2 根据逻辑运算符可知x++ 理解为true,根据短路运算符可知++y不会执行了。

根据逻辑运算可知x++||++y 返回1,则可知t=1;y没有执行，y=2

由于运算符的优先级如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70 2][]

# 数据结构数组 #

### 若稀疏矩阵采用三元组表形式进行压缩存储,若要完成对三元组表进行转置,只要将行和列对换,这种说法(    )。 ###

*  正确
 *  错误
 *  无法确定
 *  其它选项均不对

正确答案: B   你的答案: B (正确)

*  解析：例如一个矩阵需要转置  
    ![图片说明][1da988f39a4873fabe081e3c1eb6f00a.png]
 *  对应的三元组表  只记录非0数据 13 5 6的i和j位置坐标  
    ![图片说明][325e6899d107b14bab66c3181dacb512.png]
 *  矩阵的行数 n 和列数 m 的值交换；
 *  将三元组中的i和j调换；
 *  转换之后的表同样按照行序（置换前的列序）为主序，进行排序；

### 设有数组A\[i，j\]，数组的每个元素长度为3字节，i的值为1到8，j的值为1到10，数组从内存首地址BA开始顺序存放，当用以行为内存放时，元素A\[5，8\]的存储首地址为（） ###

*  BA+141
 *  BA+180
 *  BA+222
 *  BA+225

正确答案: A   你的答案: B (错误)

（4\*10+7）\*3＝141---注意数组是从一开始计算

m为行，n为列，单个元素k占多少存储单元

*           按行优先存放，第一个元素地址为a\[0\]\[0\]的话，有LOC(ai，j)=LOC(a0，0)+(i×n+j)×k；
 *           按行优先存放，第一个元素地址为a\[1\]\[1\]的话，有LOC(ai，j)=LOC(a1，1)+\[(i-1)×n+(j-1)\]×k
 *           按列优先存放，第一个元素地址为a\[0\]\[0\]的话，有LOC(ai，j)=LOC(a0，0)+(j×m+i)×k；
 *           按列优先存放，第一个元素地址为a\[1\]\[1\]的话，有LOC(ai，j)=LOC(a1，1)+\[(j-1)×m+(i-1)\]×k

上述例题：m为8，n为10，k=3;用LOC(ai，j)=LOC(a1，1)+\[(i-1)×n+(j-1)\]×k----》BA+\[(5-1)\*10+8\]\*3 =BA+141

### 假设以数组Data\[0..m-1\]存放循环队列的元素，其头尾指针分别为front和rear，则当前队列中的元素个数为 ###

*  （rear-front+m）%m
 *  rear-front+1
 *  （front-rear+m）%m
 *  （rear-front）%m

正确答案: A   你的答案: B (错误)

**循环队列**中元素个数计算方法是固定的，即(尾-头)%长度，但是由于是循环队列所以尾可能会小于头，所以要加上长度，使尾-头保持是正整数，然后再对长度求余，即元素个数

**循环队列**的相关条件和公式：   
队尾指针是rear,队头是front，其中QueueSize为循环队列的最大长度   
1.队空条件：rear==front   
2.队满条件：(rear+1) %QueueSIze==front   
3.计算队列长度：（rear-front+QueueSize）%QueueSize   
4.入队：（rear+1）%QueueSize   
5.出队：（front+1）%QueueSize

**循环队列**[百度百科 ][Link 1][https://baike.baidu.com/item/%E5%BE%AA%E7%8E%AF%E9%98%9F%E5%88%97\#reference-\[2\]-203647-wrap][https_baike.baidu.com_item_E5_BE_AA_E7_8E_AF_E9_98_9F_E5_88_97_reference-_2_-203647-wrap]

## ##

### 若有定义:int c\[4\]\[5\],( \*pc)\[5\];pc=c;那么，下列对数组C的元素引用正确的是( )。 ###

*  pc+1
 *  \* (pc+3)
 *  \* (pc+1) +3
 *  \* (\*pc+2)

正确答案: D   你的答案: C (错误)

![0438707f88ee819d011f23a563a5eaa0.png][]

pc是一个数组指针（指向数组的指针），指向列数为5的二维数组，

pc = c，表示pc指向二维数组的第一行，pc+1偏移一行，一行5个元素。

\*pc得到二维数组c的第一行数组的首地址，+2偏移到c\[0\]\[2\]的地址，解引用就得到数据2。

c\[4\]\[5\]可以理解为4个长度为5的一位数组，这四个一维数组的地址要用数组指针存放。

二维数组和一维数组的区别在于，二维数组可以理解为一维的一维。在一维中，\*表示取数值，在二维中\*表示取第几行的地址，\*\*表示取值。

### 在Visual C++和Mingw64平台short a\[100\]，sizeof(a) 返回什么？ ###

*  2
 *  4
 *  100
 *  200
 *  400

正确答案: D   你的答案: C (错误)

**short int : 2个字节**

sizeof 返回的值表示的含义如下（单位字节）：

数组 —— 编译时分配的数组空间大小；  
     指针 —— 存储该指针所用的空间大小（存储该指针的地址的长度，是长整型，应该为 4 ）；  
     类型 —— 该类型所占的空间大小；  
     对象 —— 对象的实际占用空间大小；

函数 —— 函数的返回类型所占的空间大小。函数的返回类型不能是 void 。

short a\[100\]  空间100\*2   故选D

### 优先级队列和有序数组的一个区别是() ###

*  最低优先级别的数据项不能从数组中轻易的提取出来，而在优先级队列中可以。
 *  数组必须是有序的，而优先级队列不需要。
 *  最高优先级的数据项可以很容易地从优先级队列中提取出来，而有序数组不行。
 *  其他三个选项都是。

正确答案: A   你的答案: D (错误)

A.最大堆你可以想象成一颗二叉树，堆顶元素一定是最大值，然后它的每一棵子树也都是最大堆。

优先队列的默认实现是最大堆，但是里面有个参数可以设置，设置之后就是最小堆。所以A是对的，最低优先级可以提取

B.数组和优先队列都不是有序的

C.有序数组是一种特殊的数组，里面的元素，按一定的顺序排列。有序数组可以直接提取最高优先级的元素

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70]: /images/20221023/673bd5d63df54838b3b339be76066c8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70 1]: /images/20221023/bac808aa2b7842668f109b3df0ff3d3b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2FpcXExMzY_size_16_color_FFFFFF_t_70 2]: /images/20221023/b079f26d52de442aac09fd8b07582a8e.png
[1da988f39a4873fabe081e3c1eb6f00a.png]: /images/20221023/7aa9c816491546279188b25ee834b4eb.png
[325e6899d107b14bab66c3181dacb512.png]: /images/20221023/50ca6157fbc3472db956c412156c92b2.png
[Link 1]: https://baike.baidu.com/item/%E5%BE%AA%E7%8E%AF%E9%98%9F%E5%88%97
[https_baike.baidu.com_item_E5_BE_AA_E7_8E_AF_E9_98_9F_E5_88_97_reference-_2_-203647-wrap]: https://baike.baidu.com/item/%E5%BE%AA%E7%8E%AF%E9%98%9F%E5%88%97#reference-%5B2%5D-203647-wrap
[0438707f88ee819d011f23a563a5eaa0.png]: /images/20221023/eac61549bb944ee999f81a5ba974cab5.png