数据在计算机内存中的表示是指（） 。 (2分)

1. 数据的存储结构
2. 数据结构
3. 数据的逻辑结构
4. 数据元素之间的关系

下列关于数据的逻辑结构的叙述中，（）是正确的。 (2分)

1. 数据的逻辑结构是数据元素间关系的描述
2. 数据的逻辑结构反映了数据在计算机中的存储方式
3. 数据的逻辑结构分为顺序结构和链式结构
4. 数据的逻辑结构分为静态结构和动态结构

数据结构是一门研究非数值计算的程序设计问题中计算机的（）以及它们之间的关系和运算等的学科。 (2分)

1. 操作对象
2. 计算方法
3. 逻辑存储
4. 数据映象

在数据结构中，与所使用的计算机无关的数据结构是（）。 (2分)

1. 逻辑结构
2. 存储结构
3. 逻辑结构和存储结构
4. 物理结构

在决定选取何种存储结构时，一般不考虑（）。 (2分)

1. 各结点的值如何
2. 结点个数的多少
3. 对数据有哪些运算
4. 所用编程语言实现这种结构是否方便

线性结构中元素之间存在（）关系。 (2分)

1. 一对一
2. 一对多
3. 多对多
4. 多对一

树形结构中元素之间存在（）关系。 (2分)

1. 一对一
2. 一对多
3. 多对多
4. 多对一

图形结构中元素之间存在（）关系。 (2分)

1. 一对一
2. 一对多
3. 多对多
4. 多对一

在数据结构中，从逻辑上可以把数据结构分成（ ）。 (1分)

1. 动态结构和静态结构
2. 紧凑结构和非紧凑结构
3. 线性结构和非线性结构
4. 内部结构和外部结构

与数据元素本身的形式、内容、相对位置、个数无关的是数据的（ ）。 (1分)

1. 存储结构
2. 存储实现
3. 逻辑结构
4. 运算实现

通常要求同一逻辑结构中的所有数据元素具有相同的特性，这意味着（ ）。 (1分)

1. 数据在同一范围内取值
2. 不仅数据元素所包含的数据项的个数要相同，而且对应数据项的类型要一致
3. 每个数据元素都一样
4. 数据元素所包含的数据项的个数要相等

算法的时间复杂度取决于（ ）。 (1分)

1. 问题的规模
2. 待处理数据的初态
3. 计算机的配置
4. A和B

以下数据结构中，（ ）是非线性数据结构。 (1分)

1. 树
2. 字符串
3. 队列
4. 栈

以下说法正确的是（ ）。 (1分)

1. 数据元素是数据的最小单位
2. 数据项是数据的基本单位
3. 数据结构是带有结构的各数据项的集合
4. 一些表面上很不相同的数据可以有相同的逻辑结构

数据的基本单位是（）。 (1分)

1. 数据元素
2. 文件
3. 数据项
4. 数据结构

计算机算法指的是（）。 (1分)

1. 计算方法
2. 排序方法
3. 解决问题的有限运算序列
4. 调度方法

在存储数据时，通常不仅要存储各数据元素的值，而且还要存储（）。 (1分)

1. 数据的处理方法
2. 数据元素的类型
3. 数据元素之间的关系
4. 数据的存储方法

(neuDS)链式存储设计时，各结点间的存储单元的地址( )。 (1分)

1. 一定连续
2. 一定不连续
3. 不一定连续
4. 部分连续，部分不连续

下面代码段的时间复杂度是（）。(2分)

x=n; //n>1
y=0;
while( x≥(y+1)*(y+1) )
    y++;

1. O(1)
2. O(n​1/2​​)
3. O(n)
4. O(log​2​​n)

下列代码

if ( A > B ) {
    for ( i=0; i<N*N/100; i++ )
        for ( j=N*N; j>i; j-- )
            A += B;
}
else {
    for ( i=0; i<N*2; i++ )
        for ( j=N*3; j>i; j-- )
            A += B;
}

的时间复杂度是：(2分)

1. O(N​3​​)
2. O(N​4​​)
3. O(N​5​​)
4. O(N​6​​)

下列函数

int func ( int n )
{   int i = 0, sum = 0;
    while ( sum < n )  sum += ++i;
    return i;
}

的时间复杂度是：(2分)

1. O(logn)
2. O(n​1/2​​)
3. O(n)
4. O(nlogn)

下列代码

for(i=0; i<n; i++)
  for(j=i; j>0; j/=2)
     printf(“%d\n”, j);

的时间复杂度是： (3分)

1. O(N×i)
2. O(N)
3. O(N​2​​)
4. O(NlogN)

下面代码段的时间复杂度是（）。 (2分)

x=0;  
for( i=1; i<n; i++ )  
    for ( j=1; j<=n-i; j++ )  
        x++;

1. O(n)
2. O(n​2​​)
3. O(n​3​​)
4. O(2​n​​)

要判断一个整数N（>10）是否素数，我们需要检查3到√​N​​​之间是否存在奇数可以整除N。则这个算法的时间复杂度是：(2分)

1. O(N/2)
2. O(√​N​​​)
3. O(√​N​​​logN)
4. O(0.5logN)

下列函数中，哪个函数具有最慢的增长速度：(2分)

1. N​1.5​​
2. NlogN​2​​
3. N​2​​logN
4. N(logN)​2​​

给定N×N×N的三维数组A，则在不改变数组的前提下，查找最小元素的时间复杂度是：(2分)

1. O(N​2​​)
2. O(NlogN)
3. O(N​3​​logN)
4. O(N​3​​)

计算机算法必须具备输入、输出和（可行性、确定性和有穷性）等五个特性。