数据结构与算法 概论

 数据结构概念包括数据之间的逻辑结构、数据在计算机中的存储方式和数据的运算三个方面。T

数据的逻辑结构说明数据元素之间的顺序关系，它依赖于计算机的存储结构         T

抽象数据类型与计算机内部表示和实现无关   T

抽象数据类型是一种数学概念，它描述了数据类型的行为和操作，而与计算机内部表示和实现无关。

数据项是数据的最小单位。T

数据元素是数据的基本单位，数据项是数据的最小单位，数据结构是带有结构的各数据元素的集合。

数据元素是数据的最小单位。 F

数据元素是数据的基本单位

数据的逻辑结构与数据元素本身的内容和形式无关。T

数据的逻辑结构与数据元素本身的内容和形式无关。它关注的是数据元素之间的关系和组织方式，而不涉及具体的数据内容或数据的具体形式。

算法独立于具体的程序设计语言，与具体的计算机无关。T

算法是解决问题的逻辑步骤，与特定的程序设计语言和计算机硬件无关。它提供了一个抽象的解决方案，而程序设计语言和计算机硬件则用于实现和执行这个解决方案。

解决问题的效率，跟数据的组织方式无关. T

解决问题的效率确实与数据的组织方式有很大的关系。数据的组织方式直接影响到算法的性能和效率。

时间复杂度是根据算法写成的程序在执行时耗费时间的长度，往往与输入数据的规模有关 T

时间复杂度确实是用来描述算法在执行时所需时间的一个度量，它与输入数据的规模有关。

对应同一个数据结构，可以有不同的实现方法。

对于同一个数据结构，可以有不同的实现方法。不同的实现方法可能会影响数据结构的性能、存储需求和操作效率。

算法的优劣与算法描述语言无关，但与所用计算机有关。F

好的算法描述语言可以更清晰地表达算法思路，使得算法更易于理解、实现和优化。 相反，糟糕的算法描述语言可能导致算法难以理解和实现，甚至可能产生歧义。

数据的逻辑结构是指数据的各数据项之间的逻辑关系。T

数据结构包括数据对象集以及它们的逻辑结构和物理结构，还包括与数据对象相关联的操作集，以及实现这些操作的高效的算法。T

在存储空间使用上，顺序存储结构比链式存储结构更灵活。F

在存储空间的使用上，链式存储结构通常比顺序存储结构更灵活，因为链式存储结构可以动态地分配和释放内存，不需要预先分配固定大小的空间。

对于某些算法，随着问题规模的扩大，所花的时间不一定单调增加。T

不一定单调增加。在实际应用中，具体的运行时间可能因缓存效应、资源竞争、数据排列等因素而出现不同的模式。

被计算机加工的数据元素不是孤立的，它们彼此之间一般存在某种关系，通常把数据元素之间的这种关系称为

A.规则

B.结构

C.集合

D.运算

被计算机加工的数据元素之间的关系通常被称为 结构。

以下关于数据结构的说法中正确的是（A ）。

A.数据结构的逻辑结构独立于其存储结构

B.数据结构的存储结构独立于该数据结构的逻辑结构

C.数据结构的逻辑结构唯一地决定了该数据结构的存储结构

D.数据结构仅由其逻辑结构和存储结构决定

数据结构的逻辑结构描述了数据项之间的关系和组织方式，与数据在计算机内存中的具体存储方式无关。例如，链表的逻辑结构定义了节点通过指针连接的方式，但它可以在不同的存储结构（如链式存储或数组）中实现。因此，逻辑结构独立于具体的存储结构。

数据结构在计算机内存中的表示是指（ ）。

A.数据的存储结构

B.数据结构

C.数据的逻辑结构

D.数据元素之间的关系

数据结构在计算机内存中的表示具体指的是 A. 数据的存储结构，即数据如何在内存中实际布局和管理

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

A.逻辑

B.存储

C.逻辑和存储

D.物理

数据的 逻辑 结构是与具体的计算机无关的，因为它描述了数据元素之间的关系和组织方式，而不涉及实际的存储实现。

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

A.数据的处理方法

B.数据元素的类型

C.数据元素之间的关系

D.数据的存储方法

在存储数据时，除了存储数据元素的值，还需要存储 数据元素之间的关系，以便数据结构能够有效地组织和管理数据。

数据元素在计算机存储器内表示时，物理相对位置和逻辑相对位置相同并且是连续的，称之为（ ）。

A.逻辑结构

B.顺序存储结构

C.链式存储结构

D.以上都不对

数据元素在计算机存储器内表示时，物理相对位置和逻辑相对位置相同并且是连续的，称之为 顺序存储结构。

顺序存储设计时，存储单元的地址（ ）。

A.一定连续

B.一定不连续

C.不一定连续

D.部分连续，部分不连续

在顺序存储结构中，存储单元的地址 一定是连续 的。

算法分析的两个主要方面是( )

A.空间复杂度和时间复杂度

B.正确性和简明性

C.可读性和文档性

D.数据复杂性和程序复杂性

算法分析的两个主要方面是 A. 空间复杂度和时间复杂度。

算法的计算量的大小称为计算的（ ）。

A.效率

B.复杂性

C.现实性

D.难度

算法的计算量的大小称为计算的 复杂性。它用来描述算法所需的资源（如时间和空间）如何随输入规模的变化而变化。

算法的时间复杂度取决于（ ）

A.问题的规模

B.待处理数据的初态

C.A和B

算法的时间复杂度取决于 问题的规模 和 待处理数据的初态。在大多数理论分析中，时间复杂度是关注问题规模的，但在实际应用中，数据的初态也可能影响算法的实际运行时间。

一个算法应该是（ ）

A.程序

B.问题求解步骤的描述

C.要满足五个基本特性

D.A和C

B. 问题求解步骤的描述：正确。算法是对解决特定问题的步骤和方法的系统性描述。它定义了一系列明确的操作步骤，用于从输入数据得出所需的输出结果。算法是程序设计的基础。

算法设计的要求

设计一个好的算法应该满足正确性、▁▁▁▁▁、健壮性和高效性等要求。

A.稳定性

B.可读性

C.可靠性

D.可行性

设计一个好的算法应该满足正确性、可行性、健壮性和高效性等要求。

下面的程序段违反了算法的（）原则。

void sam()
{  int n=2;
   while (n%2==0)    n+=2;
   printf(“%d”,n);
}

A.有穷性

B.确定性

C.可行性

D.健壮性

程序段违反了 健壮性 原则，因为它在特定条件下（即 n 为偶数时）会陷入一个无限循环，尽管它不会崩溃或产生错误，但它不能处理这个条件下的特殊情况。

下列程序段的时间复杂度为（）。

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

A.Θ(n)

B.Θ(n½)

C.Θ(1)

D.Θ(n2)

总结：这个程序段的时间复杂度是 Θ(√n)，因为循环次数与 √n 成正比。

使用渐近性来表示算法复杂度的原因是（ ）。

A.可以精确表示算法的复杂度

B.算法的复杂度无法使用时间单位来表示

C.研究者更关心算法的增长趋势

D.我们只研究小规模问题

C. 研究者更关心算法的增长趋势：正确。渐近分析主要用于描述算法在输入规模趋近于无限大时的行为，即增长趋势。这有助于理解算法在大规模数据上的表现，而不仅仅是其在具体输入下的实际运行时间。

算法的时间复杂度用（）来度量。

A.与硬件相关

B.相应程序的运行时间（精确到秒）

C.相应程序的运行时间（精确到毫秒）

D.算法中所有基本运算的次数

D. 算法中所有基本运算的次数：正确。时间复杂度用于度量算法中基本运算（如加法、乘法、比较等）的次数或操作数量，通常是随着输入规模的变化而变化的。这种度量帮助我们了解算法在处理不同规模问题时的效率。

使用（）来度量算法的空间复杂度。

A.存储相应程序的空间大小

B.算法运行时所占用的内存空间大小

C.函数调用次数

D.算法运行时所占用的硬盘空间大小

B. 算法运行时所占用的内存空间大小：正确。空间复杂度是衡量算法在执行过程中所需的内存空间大小的指标。它关注的是算法执行时使用的额外内存，包括用于存储数据结构、变量和临时计算结果的空间。

下面说法中，错误的是（ C）。

ⅰ.算法原地工作的含义是指不需要任何额外的辅助空间

ⅱ.在相同规模n下，复杂度为O(n)的算法在时间上总是优于复杂度为O(2n)的算法

ⅲ.所谓时间复杂度，是指最坏情况下估算算法执行时间的一个上界

ⅳ.同一个算法，实现语言的级别越高，执行效率越低

A.ⅰ

B.ⅰ,ⅱ

C.ⅰ,ⅳ

D.ⅲ

同一个算法，实现语言的级别越高，执行效率越低 是错误的说法。编程语言的级别和算法的执行效率之间的关系更复杂，并不是简单的线性关系。

.流程图是描述算法的很好的工具，一般的流程图中由几种基本图形组成。其中判断框的图形是

A.菱形

B.长方形

C.平行四边形

D.椭圆型

在流程图中，判断框的图形是 A. 菱形。判断框通常用于表示条件判断或决策，其形状是菱形。其他基本图形包括长方形（用于表示操作或处理步骤）、平行四边形（用于输入/输出操作）和椭圆型（用于表示开始或结束）。

下列复杂度表示法中，（ ）表示算法复杂度渐近的紧的界，即一种算法的复杂度与某个函数的阶相等。

A.大O表示法

B.大Θ表示法

C.大Ω标识符

D.以上都不对在复杂度表示法中，B. 大Θ表示法 表示算法复杂度渐近的紧的界，即算法的复杂度与某个函数的阶相等。大Θ表示法（Θ-notation）提供了一个算法复杂度的上下界，即给出了该算法在最坏情况、最佳情况和平均情况的时间复杂度的确切范围。

下面程序段的时间复杂度是( )

for(i=0;i<n;i++)
   for(j=1;j<m;j++)
     A[i][j]=0；

A.O(n)

B.O(m+n+1)

C.O(m+n)

D.O(m*n)

外层循环的次数是 n（i 从 0 到 n-1）。内层循环的次数是 m-1（j 从 1 到 m-1，注意 j 从 1 开始，到 m-1 结束，因此内层循环运行 m-1 次，近似为 m）。

总的操作次数是内层循环次数乘以外层循环次数，即：

• 内层循环：大约 m 次
• 外层循环：n 次

因此，总操作次数大约是 n * m。所以，这段代码的时间复杂度是 O(m * n)。

因此，正确答案是 D. O(m*n)。

下述程序段的时间复杂度为（ ）

for（i=0; i<n-1; i++）
    for（j=0; j<n-1-i; j++）
        t=a[j], a[j]=a[j+1], a[j+1]=t;

A.O(1)

B.O(n)

C.O(n2)

D.O(n3)

在存储数据时，除了存储数据元素的值之外，通常还需要存储 C. 数据元素之间的关系。这是因为在数据结构中，数据元素之间的关系决定了如何组织和访问这些数据。例如，在链表中需要存储每个元素的前驱和后继指针，在图中需要存储节点之间的连接关系等。

1. 外层循环： i 从 0 到 n - 2，总共执行了 n - 1 次。

2. 内层循环： 对于每一个 i，j 从 0 到 n - 2 - i。所以，内层循环的次数是 n - 1 - i。

   • 当 i = 0 时，j 运行 n - 1 次。
   • 当 i = 1 时，j 运行 n - 2 次。
   • ...
   • 当 i = n - 2 时，j 运行 1 次。

3. 总操作次数： 我们需要将内层循环的操作次数加总

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

   A.存储结构

   B.存储实现

   C.逻辑结构

   D.运算实现

   数据的逻辑结构指的是数据元素之间的关系和组织方式，而不涉及数据的具体存储形式或实现细节。因此，与数据元素本身的形式、内容、相对位置、个数无关的是数据的 C. 逻辑结构。

5. 在存储数据时，通常不仅要存储各数据元素的值，而且还要存储（）。

   A.数据的处理方法

   B.数据元素的类型

   C.数据元素之间的关系

   D.数据的存储方法

对算法分析的前提是（ ）。

A.算法必须简单

B.算法必须正确

C.算法结构性强

D.算法必须通用

对算法分析的前提是 B. 算法必须正确。在分析算法的性能或复杂度时，首先需要确保算法的正确性，即它能够按照预期的方式解决问题并产生正确的结果。如果算法本身不正确，任何关于其性能的分析都没有意义。

下列叙述中错误的是（ ）。

A.对于各种特定的输入,算法的时间复杂度是固定不变的

B.算法的时间复杂度与使用的计算机系统无关

C.算法的时间复杂度与使用的程序设计语言无关

D.算法的时间复杂度与实现算法过程中的具体细节无关

A. 对于各种特定的输入，算法的时间复杂度是固定不变的：这条叙述是错误的。算法的时间复杂度通常是指其在大规模输入下的增长趋势，而特定输入的实际运行时间可能会受到输入数据的影响。因此，对于不同的输入数据，算法的实际运行时间可能会有所不同，但时间复杂度本身是对所有可能输入情况的一个渐近分析。

可以用（ ）定义一个完整的数据结构。

A.数据元素

B.数据对象

C.数据关系

D.抽象数据类型

D. 抽象数据类型（ADT）：这是定义数据结构的方式，包括数据对象的集合以及定义这些数据对象上可以执行的操作。ADT 抽象地定义了数据结构及其相关操作的集合，从而提供了完整的数据结构定义。

以下说法正确的是（ ）。

A.数据项是数据的基本单位

B.数据元素是数据的最小单位

C.数据结构是带结构的数据项的集合

D.一些表面上很不相同的数据可以有相同的逻辑结构

D. 一些表面上很不相同的数据可以有相同的逻辑结构：这是正确的。不同的数据结构可能在实现上有所不同，但它们可以具有相同的逻辑结构。例如，链表和数组在实现上不同，但都可以用来实现线性列表结构。

算法性能分析的主要任务之一是分析( )

A.算法是否具有较好的可读性

B.算法中是否存在语法错误

C.算法的功能是否符合设计要求

D.算法的执行时间和问题规模之间的关系

A. 算法是否具有较好的可读性：虽然算法的可读性对理解和维护很重要，但它不属于性能分析的主要任务。性能分析主要关注算法的效率，而不是其可读性。

B. 算法中是否存在语法错误：这属于代码的正确性检查，而不是性能分析。性能分析关注的是算法的效率，而非其语法正确性。

C. 算法的功能是否符合设计要求：这是验证算法正确性的任务，确保算法按预期工作，但不涉及性能分析。性能分析关注的是算法的效率和复杂度。

D. 算法的执行时间和问题规模之间的关系：这是性能分析的核心任务。性能分析主要关注算法的时间复杂度和空间复杂度，研究算法的执行时间如何随着输入规模的增长而变化，以评估其效率。

（ ）关于算法描述不正确的是

A.对于大型的软件系统，尤其是数据量巨大的系统，算法起着决定性作用。

B.算法是由若干条指令组成的有穷序列。

C.算法的性质包括：零个或多个输入、至少一个输出、每条指令无歧义、指令的执行时间和指令执行次数不限。

D.程序和算法的区别是：程序可以是无限循环，而算法必须在有限步骤内结束。

算法的性质包括零个或多个输入、至少一个输出、每条指令无歧义、有限的执行时间和有限的执行步骤。因此，“指令的执行时间和指令执行次数不限”是不正确的，算法必须在有限的步骤内结束。

以下不属于算法的特性的是（ ）

A.有0个或多个输入

B.至少有1个输出

C.正确性

D.有穷性

 C. 正确性：尽管算法的正确性非常重要，但它不是定义算法的特性。正确性是算法设计中的要求，确保算法能正确地解决问题，但它不是算法定义的一部分。算法的定义特性包括有限性、输入输出要求等。

时间复杂度分析

下面算法的时间复杂度为 ▁▁▁▁▁。

int foo(int n) { return n * (n + 1) / 2; }

这个算法的目的是计算从 1 到 n 的整数和，即等差数列的和。具体步骤如下：

1. n * (n + 1) / 2 是一个数学计算公式，不涉及循环或递归，因此没有循环嵌套或递归调用。

2. 这段代码执行的操作是固定的，不论 n 的值是什么，计算时间都是常数时间 O(1)。

结论： 因为这个算法只进行了一次固定的数学运算，它的时间复杂度是 O(1)。

空间复杂度分析(阶乘，循环+动态数组版)

下面算法的空间复杂度为 ▁▁▁▁▁。

A.O(n)B.O(2n)C.O(n2)D.O(1)

 

double Fac(int n)
{
    int k;
    double p, *a;
    a = (double*)malloc((n + 1) * sizeof(double));
    a[0] = 1.0;
    for (k = 1; k <= n; ++k)
    {
        a[k] = a[k - 1] * k;
    }
    p = a[n];
    free(a);
    return p;
}

空间复杂度分析：

1. 动态数组 a 的空间： a 是一个动态分配的数组，大小为 n + 1。每个 double 类型占用的空间是常量，因此，a 占用的空间是 O(n)。

2. 局部变量： 变量 k 和 p 只是常量空间，且不依赖于输入规模 n。因此，它们的空间复杂度为 O(1)。

3. 总空间复杂度： 主要由动态数组 a 决定，动态数组的空间复杂度是 O(n)。局部变量所占空间是 O(1)，这对总空间复杂度没有影响。

结论： 这个算法的总空间复杂度是 O(n)。