基础算法-选择排序

选择排序 (Selection Sort)

像"选班长"一样，每次从剩下没排好序的队伍里，挑出最矮(最小)的那个人，直接让他站到队伍的最前面。然后从剩下的人里再挑最矮的，站到第二的位置。一直挑到最后，队伍就排好序了。

核心代码

c 复制代码

#include <stdio.h>

// 选择排序函数
void selectionSort(int arr[], int n) {
    // 外层循环控制排序的轮数，n个元素需要n-1轮
    for (int i = 0; i < n - 1; i++) {
        int minIndex = i; // 假设当前未排序部分的第一个元素是最小的
        
        // 内层循环：在未排序部分中寻找真正的最小值
        for (int j = i + 1; j < n; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j; // 发现更小的元素，更新最小值的下标
            }
        }
        
        // 如果找到的最小值不在当前位置，则进行交换
        if (minIndex != i) {
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
}

// 打印数组的辅助函数
void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

int main() {
    int arr[] = {64, 34, 25, 12, 22};
    int n = sizeof(arr) / sizeof(arr[0]); // 计算数组长度
    
    printf("排序前：");
    printArray(arr, n);
    
    selectionSort(arr, n); // 调用选择排序
    
    printf("排序后：");
    printArray(arr, n);
    return 0;
}

示例演示

{64, 34, 25, 12, 22}

第 1 轮：寻找整个数组的最小值

目标：把最小的数"选"出来，放到数组的第一个位置。

假设第一个元素 64 最小(minIndex = 0)。

遍历后面的元素：34 < 64，更新 minIndex = 1；25 < 34，更新 minIndex = 2；12 < 25，更新 minIndex = 3；22 > 12，不更新。

遍历结束，找到最小值为 12(下标为 3)。将 12 与第一个元素 64 交换。

第 1 轮结束：最小值 12 已经归位到最左侧。

当前数组： $12, 34, 25, 64, 22$ (12 为已排好序的部分)
第 2 轮：寻找剩余元素的最小值

目标：把第二小的数"选"出来，放到第二个位置。

从下标 1 开始，假设 34 最小(minIndex = 1)。

遍历后面的元素：25 < 34，更新 minIndex = 2；64 > 25，不更新；22 < 25，更新 minIndex = 4。

遍历结束，找到最小值为 22(下标为 4)。将 22 与下标 1 的元素 34 交换。

第 2 轮结束：第二小值 22 归位。

当前数组： $12, 22, 25, 64, 34$
第 3 轮：

目标：把第三小的数归位。

从下标 2 开始，假设 25 最小(minIndex = 2)。

遍历后面的元素：64 > 25，不更新；34 > 25，不更新。

遍历结束，最小值依然是 25(minIndex 仍为 2)。因为最小值就在原位，所以无需交换。

第 3 轮结束：第三小值 25 归位。

当前数组： $12, 22, 25, 64, 34$
第 4 轮：

目标：把第四小的数归位。

从下标 3 开始，假设 64 最小(minIndex = 3)。

遍历后面的元素：34 < 64，更新 minIndex = 4。

遍历结束，找到最小值为 34(下标为 4)。将 34 与下标 3 的元素 64 交换。

第 4 轮结束：排序完成。

最终结果： $12, 22, 25, 34, 64$

复杂度

时间复杂度是 $O(n^2)$(无论最好、最坏还是平均情况，比较次数固定)

空间复杂度是 $O(1)$(只需常数级的额外空间用于临时变量交换)