数据结构：选择排序 (Selection Sort)

#include <iostream>

void swap(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 选择排序函数框架
void selectionSort(int arr[], int n) {
    // 外层循环控制轮次，i 是当前要放置正确元素的目标位置
    // 我们需要为 arr[0], arr[1], ..., arr[n-2] 依次寻找元素
    // 当 arr[n-2] 也正确时，arr[n-1] 必然也正确了
    for (int i = 0; i < n - 1; ++i) {
        // 在这里，我们将找到无序区 arr[i...n-1] 中的最小元素，
        // 然后把它放到 arr[i] 这个位置上。
    }
}

第二阶段：实现"寻找最小元素"的逻辑（内层循环）

在每一轮中，我们需要一个内层循环来扫描整个无序区，目的是找到最小元素的索引。

cpp 复制代码

void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        // 1. 先假设当前无序区的第一个元素就是最小的
        int min_idx = i;

        // 2. 用内层循环扫描无序区的其他元素
        for (int j = i + 1; j < n; ++j) {
            // 如果发现了更小的元素...
            if (arr[j] < arr[min_idx]) {
                // ...就更新最小元素的索引
                min_idx = j;
            }
        }
        
        // 当这个内层循环结束后，min_idx 就一定指向了
        // 整个无序区中最小元素的实际位置。
        
        // 接下来就是交换操作了。
    }
}

第三阶段：完成"交换"操作

找到了最小元素的索引 min_idx 后，我们只需要将它和当前轮次的目标位置 i 的元素进行一次交换。这个交换操作发生在内层循环结束之后。

cpp 复制代码

void printArray(int arr[], int size) {
    for (int i = 0; i < size; i++) {
        std::cout << arr[i] << " ";
    }
    std::cout << std::endl;
}

// 最终的选择排序代码
void selectionSort(int arr[], int n) {
    for (int i = 0; i < n - 1; ++i) {
        // 寻找 [i, n-1] 区间里的最小元素
        int min_idx = i;
        for (int j = i + 1; j < n; ++j) {
            if (arr[j] < arr[min_idx]) {
                min_idx = j;
            }
        }

        // 将找到的最小元素与 i 位置的元素交换
        swap(&arr[min_idx], &arr[i]);

        std::cout << "第 " << i + 1 << " 轮排序后: ";
        printArray(arr, n);
    }
}

至此，一个从"全局选择最优"这个第一性原理出发的选择排序算法就清晰地构建完成了。

复杂度与特性分析

我们用之前建立的评判标准来分析它。

时间复杂度 (Time Complexity)

算法的主要耗时在于嵌套的循环。
- 外层循环执行 n-1 次。
- 内层循环的执行次数：
  - 当 i=0 时，比较 n-1 次。
  - 当 i=1 时，比较 n-2 次。
  - ...
  - 当 i=n-2 时，比较 1 次。

总的比较/移动次数大约是 1 + 2 + ... + (n−1) = n * (n−1) / 2。

⚠️ 请注意，无论输入的数组是已经有序、还是完全逆序，选择排序的这个比较次数是固定不变的。

因为它必须完整地扫描完无序区，才能确认哪个是最小的。它无法像插入排序或优化后的冒泡排序那样提前结束。

因此，选择排序的最好、最坏和平均情况的时间复杂度都是：O(n^2)

空间复杂度 (Space Complexity)

在排序过程中，我们只使用了 i, j, min_idx 这几个辅助变量。
变量数量是固定的常数，不随 n 的增长而增长。
因此，空间复杂度是：O(1)
它也是一个原地排序 (In-place Sort) 算法。

稳定性 (Stability)

这是选择排序一个非常重要的特性。我们来举个例子判断一下。
假设数组是 [5a, 8, 5b, 2] (这里 5a 和 5b 值相等，但我们为了区分，加上了标记)。
第一轮 (i=0)：
1. 扫描整个数组，发现最小元素是 2。
2. 将 2 与无序区的第一个元素 arr[0] (也就是 5a) 进行交换。
3. 交换后，数组变为 [2, 8, 5b, 5a]。
观察结果：在原始数组中，5a 在 5b 的前面。但在第一轮排序后，5a 跑到了 5b 的后面。它们的相对位置发生了改变。
仅仅一个反例就足以证明，选择排序不是一个稳定的排序算法。
因此，选择排序是❌不稳定排序 (Unstable Sort)。

选择排序的特点非常鲜明：它的时间复杂度很"死板"，不受输入数据的影响，始终是 O(n^2)。

但它有一个优点，就是数据交换的次数非常少 ，最多只有 n-1 次。在一些"写"操作远比"读"操作昂贵的场景下，这可能成为一个考虑因素。