算法奈我何（一）选择排序

一、算法背景透视

1.1 算法起源与发展

选择排序最早可追溯到1945年ENIAC计算机时代，作为早期人类对抗数据混乱的"物理性"排序方案，其设计理念深深植根于人类本能：像整理书架一样，每次挑选最显眼的元素归位。在冯·诺依曼体系架构中，这种简单直接的"比较-交换"逻辑成为早期编程语言实现排序的标准范式。

1.2 应用场景

适用场景：

教学演示场景（作为最直观的排序思想载体，常用于算法入门教学）
小规模数据排序（当数据量n<1000时性能衰减不明显）
内存敏感型环境（原地排序，空间复杂度O(1)）

二、算法原理深度拆解

2.1 核心思想可视化

想象整理书架上高低不齐的书籍：

第一轮扫描：目光扫过整个书架，锁定最矮的书籍（假设为10cm），将其与首位的29cm书籍交换
css 复制代码
```
▶️[29, 10, 14, 37, 13] → 发现10cm最矮 → [10, 29, 14, 37, 13]
```
第二轮扫描：在剩余书堆中找到13cm书籍，与第二位的29cm交换
css 复制代码
```
▷10 ▶️[29,14,37,13] → 发现13cm最矮 → [13,14,37,29]
```
第三轮扫描：发现14cm已在正确位置，无需交换
最终结果：所有书籍按从矮到高顺序排列

2.2 分步拆解演示

以数组[29, 10, 14, 37, 13]为例

第一轮：

遍历全数组找到最小值10
将10与首位的29交换 → [10,29,14,37,13]

第二轮：

在剩余元素中找到最小值13
将13与第二位的29交换 → [10,13,14,37,29]

第三轮：

剩余中最小值14已在正确位置 → 无交换

第四轮：

找到剩余数[37,29]中的最小值29
将29与第四位的37交换 → [10,13,14,29,37]

排序完毕

三、复杂度

最优情况 ：O(n²)（即使数组已有序仍需完全比较）
最差情况 ：O(n²)
空间复杂度：O(1)（原地排序，无递归栈）

四、Java实现

ini 复制代码

public class SelectionSort {
    public static void sort(int[] arr) {
        for (int i = 0; i < arr.length - 1; i++) {
            int minIndex = i;
            // 在未排序区间寻找最小值
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            // 将最小值交换到已排序序列末尾
            swap(arr, i, minIndex);
        }
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    // 测试用例
    public static void main(String[] args) {
        int[][] testCases = {
            {29, 10, 14, 37, 13},    // 标准测试
            {5, 1, 12, 5, 1},       // 重复元素
            {9, 7, 5, 3, 1},         // 逆序数组
            {1, 2, 3, 4, 5}          // 已排序
        };

        for (int[] arr : testCases) {
            sort(arr);
            System.out.println(Arrays.toString(arr));
            // 输出验证：
            // [10, 13, 14, 29, 37]
            // [1, 1, 5, 5, 12] 
            // [1, 3, 5, 7, 9]
            // [1, 2, 3, 4, 5]
        }
    }
}

五、实战优化指南

LeetCode实战

题目：215. 数组中的第K个最大元素

ini 复制代码

// 使用选择排序变种：每次找当前区间的最大值
public int findKthLargest(int[] nums, int k) {
    for(int i=0; i<k; i++){
        int maxIndex = i;
        for(int j=i+1; j<nums.length; j++){
            if(nums[j] > nums[maxIndex]) maxIndex = j;
        }
        swap(nums, i, maxIndex);
    }
    return nums[k-1];
}

六、面试向Q&A

高频考点：

时间复杂度追问
- Q：为什么无论数据是否有序，选择排序时间复杂度始终是O(n²)?
- A：算法必须严格执行n(n-1)/2次比较（等差数列求和），无法通过提前终止优化。有序性仅减少交换次数，但比较次数不变。
稳定性分析
- Q：选择排序是稳定排序吗？举例说明
- A：不稳定。例如数组[5, 5, 2]，第一轮将2与第一个5交换，导致两个5的相对顺序被破坏。
与其他O(n²)算法对比
- Q：选择排序与冒泡排序、插入排序的核心差异是什么？
- A：

维度	选择排序	冒泡排序	插入排序
交换次数	严格O(n)	最差O(n²)	最差O(n²)
适应性	无优化（始终扫描）	可优化（提前终止）	对部分有序高效
稳定性	不稳定	稳定	稳定

实战优化技巧

Q：如何优化选择排序的比较次数？

A：双向选择排序（同时找最小值和最大值），每轮减少一半扫描次数。例如：

ini 复制代码

// 每轮同时确定最小和最大值  
int left = 0, right = arr.length - 1;  
while (left < right) {  
    int minIdx = left, maxIdx = right;  
    // 扫描区间[left, right]  
    if (arr[minIdx] > arr[maxIdx]) swap(arr, minIdx, maxIdx);  
    for (int i = left + 1; i < right; i++) {  
        if (arr[i] < arr[minIdx]) minIdx = i;  
        else if (arr[i] > arr[maxIdx]) maxIdx = i;  
    }  
    swap(arr, left, minIdx);  
    swap(arr, right, maxIdx);  
    left++; right--;  
}

边界条件考察
- Q：外层循环为什么是i < arr.length - 1？
- A：当n-1个元素就位后，最后一个元素自动处于正确位置，无需处理。**
手撕代码陷阱
- Q：若将内层循环的j = i + 1误写为j = 0，会怎样？
- A：算法仍能正确排序，但比较次数变为n²次（原本为n(n-1)/2次），效率更低。
应用场景深度
- Q：为什么内存敏感场景倾向选择排序而非快速排序？
- A：快排递归栈空间复杂度最差O(n)，而选择排序严格O(1)，适合嵌入式等受限环境。