title: 选择排序
date: 2024-7-19 12:03:06 +0800
categories:
- 排序算法
tags: - 排序
- 算法
- 选择排序
description: 选择排序（Selection Sort）是一种简单直观的排序算法。它的工作原理是不断地从未排序的部分中选择最小（或最大）的元素，将其放到已排序部分的末尾，直到整个列表有序。
math: true
选择排序
选择排序(Selection-sort)是一种简单直观的排序算法。它的工作原理：首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
工作原理
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
- 然后，再从剩余未排序元素中继续寻找最小（大）元素， 然后放到已排序序列的末尾。
- 以此类推，直到所有元素均排序完毕。
图示
示例
假设有一个待排序的列表：[64, 25, 12, 22, 11]
第一步
- 初始列表：[64, 25, 12, 22, 11]
- 找到最小元素 11，与第一个元素交换位置。
11, 25, 12, 22, 64
第二步
- 剩余未排序部分：[25, 12, 22, 64]
- 找到最小元素 12，与第二个元素交换位置。
11, 12, 25, 22, 64
第三步
- 剩余未排序部分：[25, 22, 64]
- 找到最小元素 22，与第三个元素交换位置。
11, 12, 22, 25, 64
第四步
- 剩余未排序部分：[25, 64]
- 找到最小元素 25，与第四个元素交换位置。
11, 12, 22, 25, 64
第五步
- 剩余未排序部分：[64]
- 已排序完成。
复杂度分析
交换次数 O ( n ) O(n) O(n)，最好情况是，已经有序，交换0次；最坏情况是，逆序，交换 n − 1 n−1 n−1次。
交换次数比冒泡排序较少，由于交换所需CPU时间比比较所需的CPU时间多， n n n值较小时，选择排序比冒泡排序快。
原地操作几乎是选择排序的唯一优点，当空间复杂度要求较高时，可以考虑选择排序；实际适用的场合非常罕见。
-
时间复杂度为 O ( n 2 ) O(n^2) O(n2)、非自适应排序 ：外循环共 n − 1 n - 1 n−1 轮，第一轮的未排序区间长度为 n n n ，最后一轮的未排序区间长度为 2 2 2 ，即各轮外循环分别包含 n n n、 n − 1 n - 1 n−1、 ... \dots ...、 3 3 3、 2 2 2 轮内循环，求和为 ( n − 1 ) ( n + 2 ) 2 \frac{(n - 1)(n + 2)}{2} 2(n−1)(n+2) 。
-
空间复杂度为 O ( 1 ) O(1) O(1)、原地排序 ：指针 i i i 和 j j j 使用常数大小的额外空间。
-
非稳定排序相等的元素的右边，导致两者的相对顺序发生改变。
时间复杂度
- 最坏情况时间复杂度 ： O ( n 2 ) O(n^2) O(n2)
- 平均情况时间复杂度 ： O ( n 2 ) O(n^2) O(n2)
- 最好情况时间复杂度 ： O ( n 2 ) O(n^2) O(n2)
空间复杂度
- 空间复杂度 ： O ( 1 ) O(1) O(1)
代码实现
以下是选择排序的Java实现代码：
java
public class SelectionSort {
public static void selectionSort(int[] arr) {
int n = arr.length;
// 一一选择未排序部分中的最小元素
for (int i = 0; i < n-1; i++) {
// 假设当前 i 位置上的元素为最小值
int minIdx = i;
// 在未排序部分中找到最小元素
for (int j = i+1; j < n; j++) {
if (arr[j] < arr[minIdx]) {
minIdx = j;
}
}
// 将找到的最小元素与当前 i 位置上的元素交换
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}
public static void main(String[] args) {
int[] arr = {64, 25, 12, 22, 11};
selectionSort(arr);
for (int i : arr) {
System.out.print(i + " "); // 输出排序后的数组
}
}
}