专项练习数组（3）

1.对任何数据结构链式存储结构一定优于顺序存储结构(B)

A.对

B.错

解析：顺序表 优点：查找和修改（首先要查找到）效率高，空间占用比链表小，时间复杂度 O(1)；缺点：插入和删除元素时，后面的元素都需要进行移动，编译时确定大小，时间复杂度 O(n)。链表 优点：插入和删除元素比较方便，只需要修改指针，空间大小不必指定，时间复杂度 O(n)；缺点：查询和修改（首先要查找到）效率并不高，而且因为添加了指针等中间数据结构，所以空间占用比顺序表大，时间复杂度 O(1)。

2.二维数组初始化的方法是:int a[3][3]={{1},{2},{3}};说法是否正确（A）

A正确

B.错误

解析：二维数据就是以数组为元素的数组，外面的大括号表示这个数组，里面的大括号表示数组形式的元素，只有一个数字说明元素只赋了A[0][0],A[1][0],A[2][0],其余元素都没赋值。

3.设某数据结构的二元组形式表示为 A=(D ， R) ， D={01 ， 02 ， 03 ， 04 ， 05 ， 06 ， 07 ， 08 ， 09} ， R={r} ， r={<01 ， 02> ， <01 ， 03> ， <01 ， 04> ， <02 ， 05> ， <02 ， 06> ， <03 ， 07> ， <03 ， 08> ， <03 ， 09>} ，则数据结构A是（B） 。

A.线性结构

B.树型结构

C.物理结构

D.图型结构

解析：数据结构的二元组形式为：DS = (D, S)。其中 D 是数据元素的集合； S 是 D 中数据元素之间的关系集合，并且数据元素之间的关系是使用序偶来表示的。序偶是由两个元素 x 和 y 按一定顺序排列而成的二元组，记作<x , y>， x 是它的第一元素， y 是它的第二元素。
1.如果 D != null，而S == null，则该数据结构为集合结构。
2.如果 D = {01, 02, 03, 04, 05}，S = {<02,04>, <03,05>, <05,02>, <01,03>}，则该数据结构是线性结构。
在这些数据元素中有一个可以被称为“第一个”的数据元素；还有一个可以被称为“最后一个”的数据元素；除第一个元素以外每个数据元素有且仅有一个直接前驱元素，除最后一个元素以外每个数据元素有且仅有一个直接后续元素。这种数据结构的特点是数据元素之间是 1对 1 的联系，即线性关系。
3.D = {01, 02, 03, 04, 05, 06}，S = {<01,02>, <01,03>, <02,04>, <02,05>, <03,06>}
除了一个数据元素（元素 01）以外每个数据元素有且仅有一个直接前驱元素，但是可以有多个直接后续元素。这种数据结构的特点是数据元素之间是 1 对 N 的联系，即树结构。
4.D = {01, 02, 03, 04, 05}
S = {<01,02>, <01,05>, <02,01>, <02,03>, <02,04>, <03,02>,<04,02>, <04,05>, <05,01>, <05,04>}:
每个数据元素可以有多个直接前驱元素，也可以有多个直接后续元素。这种数据结构的特点是数据元素之间是 M 对 N 的联系，即图结构。显然，题目描述为情况3所述，是树结构，B选项正确。

4.若二维数组 a 有 m 列，则在数组元素 a[i][j] 前的元素个数为（  B ）

A.j * m + i

B.i * m + j

C.i * m + j - 1

D.j * m + i - 1

解析：数组下标从0开始， a[i][j]实际上是第i+1行，第j+1列的元素， 求它前面的元素个数只需先算出它前面的i行元素总个数i*m，然后再加上它所在行的前j个元素。 也就是i*m+j。

5.二维数组k[1..7,1..9],每元素大小占2个字节，而且使用列存储，a[5,4]的偏移量为（D）个字节。

A.78

B.39

C.25

D.50

解析：a[5,4]左边有三列，上方有4行。列存储的话，a[5,4]前方有3*7+4=25个元素，共50个字节。

6.下面哪项是数组优于链表的特点（D)

A.方便删除

B.方便插入

C.长度可变

D.存储空间小

解析：（1） 数组内存空间少比链表少（2）数组支持随机访问，链表不具有随机访问的特性（3）插入和删除是链表优于数组，数组需要移动被删除或者插入位置之后的元素。

7.对于下面的Java或C代码（3点），我的Array3[2][2]将返回什么（D）

A.9

B.2

C.6

D.overflow

解析：本题考查的是基本的语法知识。无论是Java语言还是C#语言，在计算机的基本语法中，数组始终是以0开始，对于一个具有n个元素的一位数组，其下标是从0到n-1。因此本例中定义的二维数组myArray3[][]，第一个元素对应的下标表示为myArray3[0][0]，问题中的myArray3[2][2]理解为第三行第三个元素，查找原始数据发现，第三行仅包含两个元素，超出了数组可访问的位置，发生溢出。Java中会报出异常java.lang.ArrayIndexOutOfBoundsException。

8.已知int a[3][4];则下列能表示a[1][2]元素值的是（A）

A.*（*（a+1）+2）

B.*(a+1+2)

C.(&a[0]+1)[2]

D.*(a[0]+1)

解析：在***数组中，数组名是第一个数组的地址.注意这里a不是第一个元素的地址,而是第一个维数组的地址,a[0][0]才是表示的一维数组第一个元素的地址.地址 + 1表示向下移一层。

9.设有序表的关键字序列为{1，4，6，10，18，35，42，53，67，71，78，84，92，99}，当用二分查找法查找键值为35的结点时，经（C）次比较后查找成功。

A.2

B.3

C.4

D.6

解析：
第1次： 1，4，6，10，18，35，42，53，67，71，78，84，92，99    ；left=0,right=13,mind=6;   mid值为42，太大
第2次：1，4，6，10，18，35，42，53，67，71，78，84，92，99    ；left=0,right=5,mind=2;   mid值为6，太小
第3次：1，4，6，10，18，35，42，53，67，71，78，84，92，99    ；left=3,right=5,mind=4;   mid值为18，太小
第4次：1，4，6，10，18，35，42，53，67，71，78，84，92，99    ；left=5,right=5,mind=5;   mid值为35，找到了

10.便于插入和删除的容器是（A、C、D）

A.list

B.vector

C.map

D.set

解析：vector 底层数据结构为数组，支持快速随机访问 ；list 底层数据结构为双向链表，支持快速增删；map、set都是STL关联容器，支持快速增删。

11. 数组元素的下标值越大，存取时间越长，这样的说法正确吗（B）

A.正确

B.不正确

解析：组存取采用首地址加上元素所在位置*元素大小计算（行优先或者列优先）其所在地址 假设一个数组为a[10][10] 数组a[0][0]地址为0x00,采用行优先存储,元素占4个字节 a[i][j]的地址为0x00+（i*10+j）*4 所以不会因为数组过长而导致存取时间变长。

12.设以下c语句中，对数组array定义后，数组元素array[1][2]的值为：（D）

A.2

B.3

C.5

D.0

解析：二维数组各元素在内存当中是连续存放的，将所有元素写在一个花括号内，会按照数组元素在内存当中的排列顺序对各元素赋初值。a[0][0],a[0][1],a[0][2],a[1][0],a[1][1]分别被赋值为1，2，3，4，5，而a[1][2]没有被赋值，所以不确定。

13.数组A的每个元素需要4个字节存放，数组有8行 10列，若数组以行为主顺序存放在内存SA开始的存储区中，则A中8行5列的元素的位置是（C）

A.SA+74

B.SA+292

C.SA+296

D.SA+300

解析：题目要求8行5列地址，其实求的就是A[7][4]地址，故位置为（7*10 + 4）* 4 = 296。

14.设有一个10阶对称矩阵A[10][10]，采用压缩存储方式按行将矩阵中的下三角部分的元素存入一维数组B[  ]中，A[0][0]存入B[0]中，则A[8][6]在B[  ]的（  C  ）位置。

A.32

B.33

C.42

D.65

解析：设有一个N阶对称矩阵A[N][N]，采用压缩存储方式按行将矩阵中的下三角部分的元素存入一维数组B[  ]中，A[0][0]存入B[0]中，则A[ i ][ j ]在B[  ]的 ((i+1) *i)/2+j 位置。

15.下列给定程序中，函数fun的功能是：把形参a所指数组中的最小值放在元素a[0]中，接着把a所指数组中的最大值放在a[1]元素中;再把a所指数组元素中的次小值放在a[2]中，把a索取数组元素中的次大值放在a[3]，以此类推。
例如:若a所指数组中的数据最初排列为：9,1,4,2,3,6,5,8,7;按规则移动后，数据排列为:1,9,2,8,3,7,4,6,5。形参n中存放a所指数组中数据的个数。
规定fun函数中的max存放的当前所找的最大值,px存放当前所找最大值得下标。 请在程序的下画线处填入正确的内容并将下画线删除，使程序得出正确的结果。（B)
试题程序。

#include<stdio.h>
#define N 9
void fun(int a[ ], int n)
{
    int i, j, max, min, px, pn, t;
    for (i = 0; i < n - 1; i += 2)
    {
 
        max = min = __;
        px = pn = i;
        for (j = i + 1; j < n; j++)
        {
 
            if (max <  __)
            {
                max = a[j];
                px = j;
            }
 
            if (min > __ )
            {
                min = a[j];
                pn = j;
            }
        }
        if (pn != i)
        {
            t = a[i];
            a[i] = min;
            a[pn] = t;
            if (px == i)
                px = pn;
        }
        if (px != i + 1)
        {
            t = a[i + 1];
            a[i + 1] = max;
            a[px] = t;
        }
    }
}
int main( )
{
    int b[N] = {9, 1, 4, 2, 3, 6, 5, 8, 7};
    printf("\nThe original data:\n");
    for (int i = 0; i < N; i++)
        printf("% 4d", b[i]);
    printf("\n");
    fun(b, N);
    printf("\nThe data after mocinng \n");
    for (int i = 0; i < N; i++)
        printf("% 4d", b[i]);
    printf("\n");
}

A.0 a[i] a[i]

B.a[i] a[j] a[j]

C.0 a[j] a[j]

D.a[i] a[i] a[i]

解析：第一空是把a中的一个元素赋给max和min  此时i=0  即填a[i]，第二空是判断max和a[j]的大小关系，第三空是判断min和a[j]的大小关系。

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

A.BA+141

B.BA+180

C.BA+222

D.BA+225

解析：5，8就证明前面有4*10+7个元素，是141。

17.给出一个由 n 个数组成的序列 A[1…n] ，要求找出它的最长单调上升子序列，设 m[i] （ 1 ≤ i ≤ n ），表示以 A[i] 结尾的最长单调上升子序列的长度，则 m[1] = 1 ， m[i] （ 1 < i ≤ n ）为（A ）。

A.m[i] = 1 + max{0，m[k]（A[k] < A[i]，1≤k < i ）}

B.m[i] = 1 + m[k] （k = i - 1 && i > 1）

C.m[i] = 1 + max{-1，m[k] （A[k] ≤ A[i]，1≤k < i ）}

D.m[i] = max{0，m[k]（A[k] < A[i]，1≤k < i ）}

18.以下数组定义中错误的是（B ）

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中的行列反了。

19.从一个长度为n的顺序表中删除第i个元素(1≤i≤n)时,需向前移动（A）个元素。

A.n-i

B.n-i+1

C.n-i-1

D.i

解析：A 假设顺序表长度为1，若要删除第1个元素，则只需移动0个元素即可。 将n=1，i=1代入到四个选项中，只有A是正确的。

20.下列关于数组与指针的区别描述正确的是(B)

A.数组要么在静态存储区被创建（如全局数组），要么在栈上被创建。

B.用运算符sizeof 可以计算出数组的容量（字节数）

C.指针可以随时指向任意类型的内存块。

D.用运算符sizeof 可以计算出指针所指向内容的容量（字节数）

解析：A.堆上创建动态数组；B.sizeof(数组名)就是数组的容量；C.const指针不可以；D. char* str = "hello"; sizeof(str)不能计算出内容的容量，只是指针的容量。