0122 绪论

news2024/9/28 21:20:55

1.绪论

1.1数据结构的基本概念

1.1部分习题

1.2算法和算法评价

1.2部分习题

1.绪论

1.1数据结构的基本概念

数据：信息的载体

数据元素：数据的基本单位，由若干数据项组成

数据项：构成数据元素的不可分割的最小单位

数据对象：具有相同性质的数据元素的集合，是数据的一个子集

数据类型：一个值的集合和定义在此集合上的一组操作的总称，原子类型、结构类型、抽象数据类型

数据结构：相互之间存在一种或多种特定关系的数据元素的集合，包括逻辑结构、存储结构、数据的运算

逻辑结构：集合、线性结构、树形结构、图状（网状）结构，可分为线性结构（线性表）和非线性结构（集合、树、图）

存储结构（物理结构）：顺序存储、链式存储、索引存储和散列存储

数据的运算：施加在数据上的运算包括运算的定义和实现，运算定义针对逻辑结构，运算实现针对存储结构

1.1部分习题

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

A 数据元素 B数据对象 C数据关系 D抽象数据类型

2.以下属于逻辑结构的是（）

A顺序表 B哈希表 C有序表 D单链表

3.以下与数据存储结构无关的术语是（）

A循环队列 B链表 C哈希表 D栈

4.链式存储设计时，结点内的存储单元地址（）

A一定连续 B一定不连续 C不一定连续 D部分连续，部分不连续

5.对于两种不同的数据结构，逻辑结构或物理结构一定不相同吗？

6.举例说明对相同的逻辑结构，同一种运算在不同存储方式下实现时，其运算效率不同

1.D

抽象数据类型描述了数据的逻辑结构和抽象运算，通常用（数据对象，数据关系，基本操作集）这样的三元组来表示，从而构成一个完整的数据结构定义

2.C

顺序表、哈希表、单链表时三种不同的数据结构，既描述逻辑结构，又描述存储结构和数据运算。而有序表指关键字有序的线性表，仅描述元素之间的逻辑关系，既可以是链式存储，也可以是顺序存储

3.D

数据的存储结构：顺序存储，链式存储，索引存储和散列存储，循环队列是用顺序表表示的队列，是一种数据结构，栈是抽象数据类型，可采用顺序存储和链式存储，只表示逻辑结构

4.A

链式存储设计，各个结点的存储空间可以不连续，但结点内的存储单元地址必须连续

对于两种不同的数据结构，它们的逻辑结构和物理结构完全有可能相同。

如二叉树和二叉排序树，二叉排序树可采用二叉树的逻辑表示和存储方式，但它们的运算定义不同，以查找结点为例，二叉树的时间复杂度为O（n），二叉排序树的时间复杂度为O（ $log_{2}n$ ）

线性表既可以用顺序存储实现，又可用链式存储实现，在顺序存储下，插入和删除元素的时间复杂度为O（n），而在链式存储下，时间复杂度为O（1）

1.2算法和算法评价

算法：对特定问题求解步骤的一种描述，是指令的有限序列，有五个重要特性（有穷性、确定性、可行性、输入、输出）

“好”算法的目标：正确性、可读性、健壮性、高效率与低存储量需求

效率的度量：时间复杂度和空间复杂度

时间复杂度：一个语句的频度是指该语句在算法中被执行的次数。算法中所有语句的频度之和记为T（n），它是该算法问题规模n的函数，时间复杂度主要分析T（n）的数量级。算法中基本运算（深层循环内的语句）的频度与T(n)同数量级，因此通常采用算法中基本运算的频度f(n)来分析算法的时间复杂度。记为：T(n)=O（f(n)），其中O含义为T（n）数量级。

算法的时间复杂度不仅依赖于问题规模n，也取决于待输入数据的性质，一般总是考虑最坏情况下的时间复杂度。

加法规则：T(n)=T1(n)+T2(n)=O(f(n))+O(g(n))=O(max(f(n),g(n)))

乘法规则：T(n)=T1(n)*T2(n)=O(f(n))*O(g(n))=O(f(n)*g(n))

常见时间复杂度：常对幂指阶

O(1)<O( $log_{2}n$ )<O(n)<O( $nlog_{2}n$ )<O( $n^{2}$ )<O( $n^{3}$ )<O( $2^{n}$ )<O(n!)<O( $n^{n}$ )

空间复杂度：该算法所耗费的存储空间，是问题规模n的函数，记为S（n）=O(g(n))

算法原地工作：指算法所需的辅助空间为常量

1.2部分习题

1.以下算法的时间复杂度为（）

void fun(int n){
    int i=1;
    while(i<=n)
        i=i*2;
}

2.以下算法的时间复杂度为（）

void fun(int n){
    int i=0;
    while(i*i*i<=n)
        i++;
}

3.程序段如下，n为正整数，最后一行语句的频度在最坏情况下是（）

for(i=n-1;i>1;i--)
    for(j=1;j<i;j++)
        if(A[j]>A[j+1])
            A[j]与A[j+1]对换

4.以下算法中最后一句的执行次数为（）

int m=0,i,j;
for(i=1;i<=n;i++)
    for(j=1;j<=2*i;j++)
        m++;

5.设n是描述问题规模的非负整数，下面程序段的时间复杂度是（）

x=2;
while(x<n/2)
x=2*x

6.求整数n（n>=0）的阶乘算法如下，其时间复杂度是（）

int fact(int n){
    if(n<=1)    return 1
    return    n*fact(n-1);
}

7.已知两长度分别为m和n的升序链表，若将它们合并为长度m+n的一个降序链表，最坏情况下时间复杂度是（）

8.下列程序段的时间复杂度是（）

count=0;
for(k=1;k<=n;k*=2)
    for(j=1;j<=n;j++)
        count++;

9.下列函数的时间复杂度是（）

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

10.下列程序段的时间复杂度是（）

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

11.下列程序段的时间复杂度是（）

int sum=0;
for(int i=1;i<n;i*=2)
    for(int j=0;j<i;j++)
        sum++;

12.一个算法所需时间由下述递归方程表示，试求出该算法的时间复杂度的级别（阶）

当n=1，T（n）=1
当n>1，T（n）=2T（n/2）+n

n是问题的规模，设n是2的整数次幂

1.O( $log_{2}n$ )

基本运算i=i*2，设执行次数为t， $2^{t}<=n$ ，即 $t<=log_{2}n$

2.O( $\sqrt[3]{n}$ )

基本运算i++，设执行次数为t，有t*t*t<=n，即 $t<=\sqrt[3]{n}$

3.O( $n^{2}$ )

当所有相邻元素为逆序时，最后一行语句每次执行，此时 $\sum_{i=2}^{n-1}\sum_{j=1}^{i-1}1=\sum_{i=2}^{n-1}i-1=(n-2)(n-1)/2=O(n^{2})$

4.n(n+1)

m++执行次数为

$\sum_{i=1}^{n}\sum_{j=1}^{2i}1=\sum_{i=1}^{n}2i=2\sum_{i=1}^{n}i=n(n+1)$

5.O( $log_{2}n$ )

基本运算为x=2*x，设执行次数为t，有 $2^{t+1}<n/2$ ，即 $t<log_{2}(n/2)-1=log_{2}n-2$

6.O(n)

每次递归调用fact()的参数减一，递归出口为fact(1)，一共执行n此递归调用fact()

7.O（max(m,n)）

两个升序链表，两两比较，当一个链表比较完后，另一个链表的剩余元素插入即可。最坏情况是两个链表中的元素依次进行比较，2max(m,n)>=m+n

8.O（ $nlog_{2}n$ ）

内层循环条件j<=n与外层循环变量无关，各自独立，每执行一次j自增1，每次内层循环都执行n次，外层循环条件k<=n，增量定义为k*=2，可知循环次数t满足k= $2^{t}<=n$ ，即 $t<=log_{2}n$ ，所以，内存循环时间复杂度为O（n），外层循环为O（ $log_{2}n$ ），根据乘法规则，得出O（ $nlog_{2}n$ ）

9.O（ $\sqrt{n}$ ）