数据结构复习

绪论

  • 如何用程序将现实问题信息化。
  • 如何用计算机高效地处理这些信息从而创造价值。

基本概念

数据： 数据是信息的载体，是描述客观事物属性的数、字符及所有能输入到计算机中并被计算机程序识别和处理的符号的集合，数据是计算机程序加工的原料。
数据元素、数据项：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。

数据结构、数据对象

数据结构是相互之间存在一种或多种特定关系的数据元素的集合。
数据对象是具有相同性质的数据元素的集合，是数据的一个子集

数据结构的三要素

逻辑结构：集合、线性结构、树形结构、图状结构（网状结构）
集合： 各个元素同属一个集合，别无其他关系。
线性结构： 数据元素之间是一对一的关系。除了第一个元素，所有元素都有唯一的前驱；除了最后一个元素，所有元素都有唯一的后继。
alt text
树形结构：数据元素之间是一对多的关系。
alt text
图结构： 数据元素之间是多对多的关系。
alt text
数据的物理结构（存储结构）:
如何用计算机标识数据元素的逻辑关系。
线性结构（逻辑结构）：
alt text
顺序存储：把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。
内存上的分布：
alt text
链式存储：把逻辑上相邻的元素在物理位置上可以不相邻，借助提示元素存储地址的指针来表示元素之间的逻辑关系。
内存上的表示：
alt text
索引存储：在存储元素信息的同时，还建立附加的索引标。索引表中的每项称为索引项，索引项的一般形式是（关键字，地址）
内存表示：
alt text
散列存储：根据元素的关键字直接计算出该元素的存储地址，又称哈希（Hash）存储。

  1. 若采用顺序存储，则各个数据元素在物理上必须是连续的；若采用非顺序存储，则各个数据元素在物理上可以是离散的。
  2. 数据的存储结构会影响存储空间分配的方便程度。
  3. 数据的存储结构会影响对数据运算的速度。

数据的运算：施加在数据上的运算包括运算的定义和实现。运算的定义是针对逻辑结构的，指出运算的功能：运算的实现是针对存储结构的，指出运算的具体操作步骤。

数据类型、抽象数据类型：
数据类型是一个值的集合和定义在此集合上的一组操作的总称。

  1. 原子类型，其值不可再分的数据类型。（int，bool）
  2. 结构类型。其值可以在分解为若干成分（分量）的数据类型。（结构体）。

**抽象数据类型（Abstract Data Type，ADT）**是抽象数据组织及与之相关的操作。（用数学化的语言定义数据的逻辑结构、定义运算。与具体的实现无关。）
alt text
数据结构这门课着重关注的是数据元素之间的关系，和对这些数据元素的操作，而不关心具体的数据项内容
alt text

算法的基本概念

alt text

什么是算法

程序 = 数据结构 + 算法
数据结构：如何如数据正确地描述现实世界的问题，并存入计算机。
算法(Algorithm)是对特定问题求解步骤的一种描述，它是指令的有限序列，其中的每条指令表示一个或多个操作，也就是求解问题的步骤。(如何高效处理这些数据，以解决实际问题)。
例子：如做食材，又如按照顺序递归进行年龄排序。

算法的特性
  1. 有穷性**：一个算法必需总在执行有穷步之后结束，且每一步都可在有穷时间内完成。
    注：算法必需是有穷的，而程序可以是无穷的。（如微信可以一直运行）
  2. 确定性**：算法中每条指令必须有确切的含义，对于相同的输入只能得出相同的输出。
  3. 可行性：算法中描述的操作都可以通过已经实现的基本运算执行有限次来实现。
  4. 输入：一个算法有零个或多个输入，这些输入取自某个特定对象的集合。
  5. 输出：一个算法有一个或多个输出，这些输出是与输入有着某种特定关系的量。
"好"算法的特制
  1. 正确性。算法应该能够正确的解决求解问题。
  2. 可读性。算法应具有良好的可读性，帮助人们理解。
  3. 健壮性。输入非法数据时，算法能适当地做出反应或进行处理，而不会产生莫名其妙的输出结果。
  4. 高效率与低存储量需求。花的时间少并且节省内存。(事件复杂度低、空间复杂度低)。

时间复杂度

如何评估算法事件开销？
需要排除与算法本身无关的外界因素，且能够事先预估
算法时间复杂度：
事前预估算法事件开销T(n)与问题规模n的关系(T标识"time")
$T = T(n)$

1
2
3
4
5
6
7
8
9
10
11
12
13
// 算法1-逐步递增型爱你
void loveYou(int n) {
  int i = 1;
  while(i <= n ) {
    i ++ ;
    printf("I love You %d\n", i);

  }
  int main() {
    loveYou(3000);
    return 0;
  }
}

语句频度
$T(3000) = 1 + 3001 + 3000 * 2 +1$
时间开销与问题规模n的关系：
$T(n) = 3n + 3$
当表达式很复杂之后，是否可以忽略表达式的某些部分？
可以忽略较低阶的部分，只考虑保留高阶的部分。
$T(n) = O(f(n))$
只需要关注数量级。

  1. 加法规则
    $T(n) = T_1(n) + T_2(n) = O(f(n)) + O(g(n)) = O(max(f(n), g(n)))$
    多项相加，只保留最高阶的项，且系数变为1
  2. 乘法规则
    $T(n) = T_1(n) * T_2(n) = O(f(n)) * O(g(n)) = O(f(n) * g(n))$
    多项相乘，都保留

eg：$T_3(n) = n^3 + n^2 * log2n = O(n^3) + O(n^2 * \log_2n) $

常见时间复杂度数量级比较:
$$
O(1) < O(\log_2(n)) < O(n) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
$$
alt text
alt text
小tips：常对幂指阶（越往后，算法越差）
若代码量足够大，是否还需要按照上述方法按行去数？
结论：顺序执行的代码只会影响常数项，可以忽略；只需要挑循环中的一个基本操作分析它的执行次数与n的关系即可；如果多层嵌套循环，只需要关注最深层循环了几次，找到执行次数与n的关系即可。
例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void loveYou(int flag[], int n) {
  printf("I am Iron Man\n");
  for (int i = 0; i < n; i++) {
    if (flag[i] == n) {
      printf("I Love You %d\n", n);
      break
    }
  }
}

int main() {
  int flag[n] = {};
  loveYou(flag, n);
}

上述算法中，可以引伸出两种事件复杂度：
若n位于flag数组的首部，则称为最好时间复杂度$T(n) = O(1)$
若n位于flag数组的尾部，则称为最差时间复杂度$T(n) = O(n)$
若n在任意一个位置的概率相同，为$1/n$，则称为平均时间复杂度$T(n) = O(n)$
最坏时间复杂度：最坏情况下算法的时间复杂度。
最好时间复杂度：最好情况下算法的时间复杂度。
平均时间复杂度：所有输入示例等概率出现的情况下，算法的期望运行时间。
alt text
小故事：算法的性能只有在n很大时才会暴露出来。

空间复杂度

无论问题规模怎么变，算法运行所需要的内存空间都是固定的常量，算法空间复杂度为：
$$
S(n) = O(1)
$$
算法原地工作–算法所需的内存空间为常量。
只需要关注存储空间大小与问题规模相关的变量。

1
2
3
4
5
6
void test(int n) {
  int flag[n][n];
  int other[n];
  int i;
  // …………
}

$$
S(n) = O(n^2)+O(n)+O(1)
$$

函数递归调用带来的内存开销：

1
2
3
4
5
6
7
8
9
10
11
12
13
void loveYou(int n) {
  int a, b, c;
  // ………………
  if(n > 1) {
    loveYou(n-1);
  }
  printf("I love you %d\n", n);
}

int main() {
  loveYou(5);
  return 0;
}

alt text

空间复杂度=递归调用的深度。
alt text

小结