21、基础算法与顺序统计量详解

tensorflowjs6

墨衍会员 · AI 创作全网分发码龄3年

关注

原创最新推荐文章于 2026-06-03 18:00:00 发布 106 阅读 AI 写同款· GEO 优化 ›

离散数学实战指南专栏收录该内容

¥69.90 ¥499.90

26篇文章

订阅专栏

超级会员免费看

基础算法与顺序统计量详解

1. 快速排序算法复杂度分析

在分析快速排序算法复杂度时，我们从一个递推关系开始。首先对变量进行变换，将 (N) 变为 (N - 1)，得到 ((N - 1)A(N - 1) = N(N - 1) + 2\sum_{i = 0}^{N - 2}A(i))。从这个等式可以推导出 (N A(N) = (N + 1)A(N - 1) + 2N)。
将等式两边同时除以 (N(N + 1))，得到 (\frac{A(N)}{N + 1} = \frac{A(N - 1)}{N} + \frac{2}{N + 1})。令 (\overline{A}(N)=\frac{A(N)}{N + 1})，则递推关系变为：
[
\begin{cases}
\overline{A}(N) = \overline{A}(N - 1) + \frac{2}{N + 1}, & N \geq 2 \
\overline{A}(0) = \overline{A}(1) = 0
\end{cases}
]
使用代入法求解这个递推关系，得到 (\overline{A}(N) = 2\sum_{i = 3}^{N + 1}\frac{1}{i})。考虑到渐近关系，最终快速排序算法的复杂度为 (A(N) = (N + 1)\overline{A}(N) = 2N \ln N + \Theta(N))。

2. 顺序统计量的定义

顺序统计量问题涵盖了寻找多个数中的最小值、最大值和中位数等特殊情况。对于一个非空有限集 (A = {a_1, a_2, \ldots, a_N})，引入了反对称和传递关系，且所有元素两两可比，其第 (k) 阶顺序统计量是向量 ((a_{j_1}, \ldots, a_{j_k}, \ldots, a_{j_N})) 的第 (k) 个分量，其中向量的分量是有序的（(1 \leq k \leq N)）。例如，(a_1, a_2, \ldots, a_N) 中的最小值就是该集合的第一阶顺序统计量。在统计研究中，寻找顺序统计量，特别是中位数，是非常必要的。

3. 求解第 (k) 阶顺序统计量的方法

3.1 使用 `Partition` 过程的方法

假设要确定数组 list[1..N] 中的第 (k) 大元素，记为 (t)。可以使用 Partition 过程来解决这个问题。当枢轴元素 (v) 在数组 list 中占据最终位置 list[i] 时，数组中小于或等于 (v) 的元素个数为 (i - 1)，大于或等于 (v) 的元素个数为 (N - i)。此时有三种情况：
- (k < i)，则所求元素 (t) 位于子数组 list[1..(i - 1)] 中；
- (k = i)，则 (t = list[i])；
- (k > i)，则 (t) 位于子数组 list[(i + 1)..N] 中。

以下是使用 Partition 过程的 SelectPart 函数代码：

function SelectPart(var list : Mass; k: integer): integer;
var
  found: boolean;
  left, right, v: integer;
begin
  left := 1;
  right := N + 1;
  list[N + 1] := MaxInt;
  found := false;
  repeat
    v := Partition(list, left, right);
    case compare(k, v) of
      -1: right := v - 1;
      0: begin
        found := true;
        result := v;
      end;
      +1: left := v + 1;
    end;
  until found;
end;

该算法的渐近分析与快速排序复杂度的研究类似。平均情况下，算法 SelectPart 的复杂度为 (A(N) = \Theta(N))，最坏情况下为 (W(N) = \Theta(N^2))。

3.2 `SelectOpt` 算法

SelectOpt 算法的复杂度为 (O(N))。其操作步骤如下：
1. 将数组 list[left..right] 的元素划分为 (\lfloor\frac{N}{w}\rfloor) 个子数组，每个子数组有 (w) 个元素（(w) 是大于 1 的整数）；
2. 找到每个子数组的中位数 (m_i)（(1 \leq i \leq \lfloor\frac{N}{w}\rfloor)）；
3. 确定中位数集合 (M = {m_i : 1 \leq i \leq \lfloor\frac{N}{w}\rfloor}) 的中位数 (\mu)；
4. 将 (\mu) 作为 Partition 过程的枢轴元素，应用于数组 list[left..right] ；
5. 如果未找到所求元素 (t)，则通过改变 left 或 right 的值缩小搜索范围，返回第一步；如果找到元素 (t)，算法停止。

以下是 SelectOpt 算法的代码实现：

const
  w = 5;
function SelectOpt(var list : Mass; k, left, right : integer): integer;
var
  i, d, dd, v, temp: integer;
begin
  while (true) do
  begin
    d := right - left + 1;
    if (d <= w) then
    begin
      InsertionSort(list, left, right);
      result := left + k - 1;
      break;
    end;
    dd := Floor(d / w);
    for i := 1 to dd do
    begin
      InsertionSort(list, left + (i - 1) * w, left + i * w - 1);
      swap(list[left + i - 1], list[left + (i - 1) * w + Ceil(w / 2) - 1]);
    end;
    v := SelectOpt(list, Ceil(dd / 2), left, left + dd - 1);
    swap(list[left], list[v]);
    v := Partition(list, left, right);
    temp := v - left + 1;
    case compare(k, temp) of
      -1: right := v - 1;
      0: begin
        result := v;
        break;
      end;
      +1: begin
        k := k - temp;
        left := v + 1;
      end;
    end;
  end;
end;

从分析可知，在足够大的 (N) 时，下一次循环适用的数组元素不超过 (\frac{3N}{4} + \Theta(1)) 个。最坏情况下，数组元素比较次数的递推关系为：
[
\begin{cases}
T(N) = T(\lfloor\frac{N}{w}\rfloor) + T(\frac{3N}{4}) + \Theta(N), & N > w \
T(1), T(2), \ldots, T(w) \text{ — 常数}
\end{cases}
]
当 (w \geq 5) 时，该递推关系的解为 (T(N) = \Theta(N))，即 SelectOpt 算法的复杂度与原数组元素个数呈线性关系。

4. 相关问题及算法复杂度分析

以下是一系列与算法复杂度分析、排序和搜索相关的问题：
| 问题编号 | 问题描述 |
| ---- | ---- |
| 12.1 | 给出阶乘计算算法渐近复杂度的精确估计 |
| 12.2 | 估计无递归阶乘计算算法的复杂度 |
| 12.3 | 编写计算第 (n) 个斐波那契数的递归算法并分析其复杂度 |
| 12.4 | 验证一个计算第 (n) 个斐波那契数的内存受限复杂度算法 |
| 12.5 | 估计计算 (\lfloor\log_2 n\rfloor) 的递归算法的复杂度 |
| 12.6 | 使用递推定义计算矩阵的行列式 |
| 12.7 | 计算三对角矩阵的行列式 |
| 12.8 | 计算一般三对角矩阵的行列式 |
| 12.9 | 从文件中读取矩阵元素，使用递归计算行列式并输出结果到文件 |
| 12.10 | 估计递归计算 (n \times n) 矩阵行列式算法的乘法运算次数 |
| 12.11 | 证明递归计算 (n \times n) 矩阵行列式算法的精确乘法运算次数公式 |
| 12.12 | 对于元素为 (0) 或 (1) 的矩阵，改进递归计算行列式算法以减少乘法运算次数 |
| 12.13 | 估计考虑矩阵中零元素的行列式计算算法的乘法运算次数 |
| 12.14 | 计算考虑零元素的三对角矩阵行列式算法的乘法运算次数 |
| 12.15 | 给出顺序搜索算法在目标元素可能不存在时的比较次数精确估计 |
| 12.16 | 计算在给定数组中使用二分搜索查找目标值的比较次数 |
| 12.17 | 计算二分搜索在给定数组中平均比较次数 |
| 12.18 | 找出二分搜索在给定数组中的最小和最大比较次数 |
| 12.19 | 计算二分搜索在给定数组中成功和失败搜索的平均比较次数 |
| 12.20 | 估计二分搜索在目标元素可能不存在时的比较次数 |
| 12.21 | 证明二分搜索算法分析中使用的关系 |
| 12.22 | 提出二分搜索算法中计算 middle 变量避免溢出的改进方法 |
| 12.23 | 构建斐波那契搜索的决策树 |
| 12.24 | 证明斐波那契搜索算法平均情况下的渐近复杂度 |
| 12.25 | 实现顺序搜索、二分搜索、斐波那契搜索和插值搜索，并比较复杂度 |
| 12.26 | 演示插入排序算法在升序和降序排序中的操作 |
| 12.27 | 判断插入排序是否稳定 |
| 12.28 | 使用插入排序对文件中的数组进行升序排序，并输出排序结果和比较次数 |
| 12.29 | 判断二分插入排序与标准插入排序的渐近复杂度是否不同 |
| 12.30 | 判断二分插入排序是否稳定 |
| 12.31 | 演示冒泡排序和摇摆排序在升序和降序排序中的操作 |
| 12.32 | 判断冒泡排序和摇摆排序是否稳定 |
| 12.33 | 使用摇摆排序对文件中的数组进行升序排序，并输出排序结果和比较次数 |
| 12.34 | 计算给定数组的逆序对数量 |
| 12.35 | 计算给定数组的逆序对数量 |
| 12.36 | 计算两个特定数组的逆序对数量 |
| 12.37 | 证明给定整数数组的逆序对数量公式 |
| 12.38 | 计算交换一维数组中两个元素可消除的最大逆序对数量 |
| 12.39 | 已知数组中逆序对数量，求数组的最小大小 |
| 12.40 | 已知数组的逆序对数量，求其逆序数组的逆序对数量 |
| 12.41 | 证明插入排序对含 (I) 个逆序对的数组排序的比较次数公式 |
| 12.42 | 判断希尔排序是否稳定 |
| 12.43 | 分析基于特定增量序列的希尔排序算法的主要缺点 |
| 12.44 | 分析希尔排序中使用选择排序替代插入排序对渐近复杂度的影响 |
| 12.45 | 证明 (h) - 排序和 (k) - 排序的定理 |
| 12.46 | 写出普拉特建议的增量序列在数组大小为 (N = 32) 时的元素 |
| 12.47 | 演示基于普拉特增量序列的希尔排序算法操作 |
| 12.48 | 证明基于普拉特增量序列的希尔排序最坏情况下的渐近复杂度 |
| 12.49 | 使用不同增量序列的希尔排序对文件中的数组进行升序排序，并输出排序结果和比较次数 |
| 12.50 | 求出上一题中增量序列的显式表达式 |
| 12.51 | 计算快速排序对给定数组排序的比较次数 |
| 12.52 | 判断快速排序是否稳定 |
| 12.53 | 给出非严格单调但导致快速排序最坏情况的序列示例 |
| 12.54 | 估计快速排序对元素全相等数组排序的比较次数 |
| 12.55 | 写出选择三个元素中位数作为枢轴的快速排序的比较次数递推关系 |
| 12.56 | 找出快速排序在数组大小 (N < 15) 时执行最大比较次数的数组 |
| 12.57 | 填写已知排序算法的比较表 |
| 12.58 | 找出给定数组的中位数 |
| 12.59 | 找出两个特定数组的中位数 |
| 12.60 | 写出计算三个实数中位数的显式公式 |
| 12.61 | 证明确定数组中第 (k) 大元素的决策树的叶子数下限 |
| 12.62 | 证明确定数组中第 (k) 大元素的算法的比较次数下限 |
| 12.63 | 证明不存在比较次数小于 (N + \lceil\log_2 N\rceil - 2) 确定数组中第二大元素的算法 |
| 12.64 | 确定找出五个任意数中位数的最小比较次数 |
| 12.65 | 证明找出数组中位数的比较次数下限 |
| 12.66 | 演示 SelectPart 算法在寻找数组中位数中的操作 |
| 12.67 | 计算 SelectPart 算法在特定数组中寻找中位数的比较次数 |
| 12.68 | 演示 SelectOpt 算法在寻找数组中位数中的操作 |

下面是 SelectOpt 算法的流程图：

graph TD;
    A[开始] --> B[计算d = right - left + 1];
    B --> C{d <= w?};
    C -- 是 --> D[插入排序];
    D --> E[返回结果并结束];
    C -- 否 --> F[计算dd = Floor(d / w)];
    F --> G[循环i从1到dd];
    G --> H[对每个子数组插入排序];
    H --> I[交换元素];
    G --> J{i < dd?};
    J -- 是 --> G;
    J -- 否 --> K[递归调用SelectOpt];
    K --> L[交换元素];
    L --> M[Partition操作];
    M --> N[计算temp = v - left + 1];
    N --> O{compare(k, temp) = -1?};
    O -- 是 --> P[更新right = v - 1];
    P --> B;
    O -- 否 --> Q{compare(k, temp) = 0?};
    Q -- 是 --> R[返回结果并结束];
    Q -- 否 --> S[更新k = k - temp, left = v + 1];
    S --> B;

通过以上内容，我们详细介绍了快速排序算法复杂度的分析、顺序统计量的概念以及求解顺序统计量的方法，同时还列举了一系列相关的问题及算法复杂度分析，希望能帮助读者更好地理解和掌握这些基础算法。

5. 部分问题的详细解答与分析

5.1 阶乘计算算法复杂度

递归阶乘算法 ：递归计算阶乘的算法，其复杂度分析可以通过递推关系来进行。设 (T(n)) 表示计算 (n!) 的时间复杂度，递归公式为 (n!=n\times(n - 1)!)，则 (T(n)=T(n - 1)+O(1))，通过递推可得 (T(n)=O(n))。
无递归阶乘算法 ：以下是无递归阶乘计算的代码：

function factorial(n: integer): integer;
var
  i, f: integer;
begin
  f := 1;
  for i := 2 to n do
    f := f * i;
  factorial := f;
end;

该算法通过一个循环从 2 到 (n) 进行乘法运算，时间复杂度同样为 (O(n))。

5.2 斐波那契数计算算法

递归算法 ：递归计算第 (n) 个斐波那契数的代码如下：

function fibonacci(n: integer): integer;
begin
  if (n = 0) or (n = 1) then
    fibonacci := n
  else
    fibonacci := fibonacci(n - 1) + fibonacci(n - 2);
end;

该算法的复杂度分析可以通过递推关系 (T(n)=T(n - 1)+T(n - 2)+O(1)) 来进行，其时间复杂度为 (O(2^n))，因为递归过程中存在大量的重复计算。
- 内存受限复杂度算法 ：

function fib(n: integer): integer;
var
  a, b, i: integer;
begin
  a := 0;
  b := 1;
  for i := 2 to n do
  begin
    b := a + b;
    a := b - a;
  end;
  if n = 1 then
    fib := 1
  else
    fib := b;
end;

该算法通过迭代的方式，只使用了常数级的额外空间，时间复杂度为 (O(n))。

5.3 二分搜索算法相关问题

比较次数计算 ：在数组 (21, 24, 33, 37, 38, 45, 50) 中搜索目标值 (22)，二分搜索的过程如下：
- 首先取中间元素 (37)，(22<37)，则在左半部分继续搜索；
- 左半部分中间元素为 (24)，(22<24)，继续在左半部分搜索；
- 此时左半部分只有一个元素 (21)，(22>21)，搜索失败。总共进行了 3 次比较。
平均比较次数 ：当元素已知存在于数组中时，二分搜索的平均比较次数可以通过分析搜索树的结构来计算。对于长度为 (n) 的有序数组，平均比较次数约为 (\log_2 n)。

5.4 排序算法稳定性与复杂度分析

插入排序 ：插入排序是稳定的排序算法，因为在插入元素时，相等元素的相对顺序不会改变。其时间复杂度在最好情况下为 (O(n))（数组已经有序），最坏情况下为 (O(n^2))。
冒泡排序和摇摆排序 ：冒泡排序和摇摆排序都是稳定的排序算法。冒泡排序通过相邻元素的比较和交换来排序，时间复杂度为 (O(n^2))。摇摆排序是冒泡排序的改进，它在正向和反向交替进行比较和交换，平均情况下性能略优于冒泡排序，但最坏情况下复杂度仍然为 (O(n^2))。
希尔排序 ：希尔排序的稳定性取决于增量序列的选择。一般情况下，希尔排序是不稳定的。基于增量序列 (1, 2, 4, 8, \ldots) 的希尔排序，其主要缺点是在排序过程中，元素只能在相隔 (2^k) 的位置上移动，导致排序效率较低。当使用选择排序替代插入排序进行 (h) - 排序时，希尔排序的渐近复杂度仍然为 (O(n^2))。

6. 顺序统计量相关问题的深入探讨

6.1 中位数计算

数组中位数计算 ：对于数组 (20, 12, 18, 16, 24, 10, 22, 14)，可以使用 SelectPart 或 SelectOpt 算法来计算中位数。首先对数组进行排序，排序后为 (10, 12, 14, 16, 18, 20, 22, 24)，中位数为 (\frac{16 + 18}{2}=17)。
特殊数组中位数 ：对于数组 (N, 1, N - 1, 2, N - 3, \ldots, \lceil N/2\rceil)，当 (N) 为奇数时，中位数为 (\lceil N/2\rceil)；当 (N) 为偶数时，中位数需要根据具体的计算方法来确定。

6.2 顺序统计量算法比较

SelectPart 算法 ：该算法在平均情况下复杂度为 (\Theta(N))，但最坏情况下复杂度为 (\Theta(N^2))。其优点是实现相对简单，基于 Partition 过程。
SelectOpt 算法 ： SelectOpt 算法的复杂度为 (O(N))，通过划分、找中位数、再划分的步骤，在最坏情况下也能保证线性复杂度。但该算法的实现相对复杂，需要处理子数组划分、中位数计算等问题。

7. 总结

本文详细介绍了基础算法中的快速排序复杂度分析、顺序统计量的概念及求解方法，同时对一系列相关问题进行了探讨。在算法复杂度分析方面，我们通过递推关系、渐近分析等方法，对阶乘计算、斐波那契数计算、搜索和排序算法的复杂度进行了深入研究。在顺序统计量方面，我们介绍了 SelectPart 和 SelectOpt 两种算法，并分析了它们的优缺点和复杂度。

通过对这些基础算法的学习和理解，我们可以更好地选择合适的算法来解决实际问题。例如，在需要寻找数组中第 (k) 大元素时，如果对最坏情况复杂度有要求，可以选择 SelectOpt 算法；如果对实现的简单性更看重，可以选择 SelectPart 算法。同时，对于排序和搜索算法，我们需要根据数组的特点和实际需求来选择合适的算法，以提高算法的效率。

希望本文能为读者提供一个全面的基础算法学习和理解的参考，帮助读者在实际编程和算法设计中更好地应用这些知识。

以下是部分排序算法的复杂度和稳定性比较表格：
| 排序算法 | 平均复杂度 | 最坏复杂度 | 最好复杂度 | 稳定性 |
| ---- | ---- | ---- | ---- | ---- |
| 插入排序 | (O(n^2)) | (O(n^2)) | (O(n)) | 稳定 |
| 冒泡排序 | (O(n^2)) | (O(n^2)) | (O(n)) | 稳定 |
| 希尔排序 | 取决于增量序列 | 取决于增量序列 | 取决于增量序列 | 不稳定 |
| 快速排序 | (O(n\log n)) | (O(n^2)) | (O(n\log n)) | 不稳定 |

下面是二分搜索算法的流程图：

graph TD;
    A[开始] --> B[设置left = 0, right = n - 1];
    B --> C{left <= right?};
    C -- 是 --> D[计算middle = (left + right) / 2];
    D --> E{target = array[middle]?};
    E -- 是 --> F[返回middle并结束];
    E -- 否 --> G{target < array[middle]?};
    G -- 是 --> H[更新right = middle - 1];
    H --> C;
    G -- 否 --> I[更新left = middle + 1];
    I --> C;
    C -- 否 --> J[返回 -1 表示未找到并结束];

通过以上内容，我们对基础算法和顺序统计量相关的知识进行了全面而深入的探讨，希望能为读者在算法学习和应用方面提供有力的支持。