数组（二）———数组的排序算法①
目录
冒泡排序
基本步骤：
复杂度分析
实现示例（Java）：
选择排序
基本步骤：
复杂度分析
实现示例（Java）：
插入排序
基本步骤：
复杂度分析
实现示例（Java）：
希尔排序
基本步骤：
复杂度分析
实现示例（Java）：
归并排序
基本步骤：
复杂度分析
实现示例（Java）：
冒泡排序
定义：
冒泡排序（Bubble Sort）是一种简单的排序算法，其基本思想是重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素，这意味着数列已经排序完成。
基本步骤：
- 比较相邻的元素：如果第一个比第二个大，就交换它们两个。
- 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后一个元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
复杂度分析
时间复杂度分析：
最好情况：当输入的数据已经是排序好的时候，冒泡排序只需要进行一次遍历来确认所有元素都已正确排序，此时的时间复杂度为O(n)。
最坏情况和平均情况：当输入的数据是逆序或者随机无序时，冒泡排序的时间复杂度为O(n^2)，其中n是数组的长度。
空间复杂度：
冒泡排序是原地排序算法，不需要额外的存储空间，因此空间复杂度为O(1)。
稳定性：冒泡排序是稳定的排序算法，因为相等的元素不会改变它们的相对位置。
实现示例（Java）：
以下是一个使用Java实现的冒泡排序示例：
public class BubbleSort {
public static void bubbleSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
boolean swapped;
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
swapped = false;
for (int j = 0; j < n - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
// 交换元素
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
// 如果在某一趟中没有发生任何交换，说明数组已经有序，可以直接结束
if (!swapped) {
break;
}
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
bubbleSort(arr);
System.out.println("冒泡排序后的数组 : ");
//增强for循环遍历数组中的元素
for (int value : arr) {
System.out.print(value + " ");
}
}
}
选择排序
定义：
选择排序（Selection Sort）是一种简单直观的比较排序算法。它的基本思想是在未排序序列中找到最小（或最大）元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（或最大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。
基本步骤：
- 初始化：从数组的第一个元素开始，将当前元素视为最小值。
- 查找最小值：在剩余的未排序元素中找到最小值的位置。
- 交换：如果找到的最小值不是当前位置的元素，则与当前位置的元素交换。
- 移动到下一个元素：将当前元素位置向右移动一位，重复上述过程，直到整个数组排序完成。
复杂度分析
时间复杂度分析：
最好情况、最坏情况和平均情况：无论数组是否已经排序，选择排序都需要执行完整的比较和交换过程，因此时间复杂度始终为O(n^2)，其中n是数组的长度。
空间复杂度：
选择排序是原地排序算法，不需要额外的存储空间，因此空间复杂度为O(1)。
稳定性：
选择排序是不稳定的排序算法，因为在排序过程中可能会改变相同元素的相对位置。
实现示例（Java）：
以下是一个使用Java实现的选择排序示例：
public class SelectionSort {
public static void selectionSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
int n = arr.length;
for (int i = 0; i < n - 1; i++) {
// 假设i位置的元素是最小的
int minIndex = i;
// 在i+1到n-1之间找到最小的元素
for (int j = i + 1; j < n; j++) {
if (arr[j] < arr[minIndex]) {
minIndex = j;
}
}
// 将找到的最小元素与i位置的元素交换
if (minIndex != i) {
int temp = arr[i];
arr[i] = arr[minIndex];
arr[minIndex] = temp;
}
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
selectionSort(arr);
System.out.println("选择排序后的数组 : ");
for (int value : arr) {
System.out.print(value + " ");
}
}
}
插入排序
定义：
插入排序（Insertion Sort）是一种简单直观的比较排序算法，其工作原理类似于人们玩扑克牌时整理手中的牌的方式。插入排序的基本思想是将一个记录插入到已排序好的有序表中，从而得到一个新的、记录增1的有序表。初始时，认为数组中的第一个元素是一个有序的子数组。
基本步骤：
- 初始化：假设数组的第一个元素已经排好序，将其看作是一个有序的子数组。
- 遍历数组：从数组的第二个元素开始，依次遍历每个元素。
- 插入操作：对于当前遍历到的元素，将其与前面已排序的子数组中的元素进行比较，找到合适的位置插入。具体操作是从当前元素开始向前遍历已排序的子数组，将大于当前元素的元素向后移动一位，直到找到小于等于当前元素的元素或到达子数组的开头，然后将当前元素插入到该位置。
- 重复步骤2和3：直到遍历完数组中的所有元素。
复杂度分析
时间复杂度分析：
最好情况：当输入数据已经是排序好的情况下，插入排序的时间复杂度为O(n)，因为每个元素只需比较一次就能确定位置。
最坏情况和平均情况：当输入数据是逆序或随机无序的情况下，插入排序的时间复杂度为O(n^2)，其中n是数组的长度。
空间复杂度：
插入排序是原地排序算法，不需要额外的存储空间，因此空间复杂度为O(1)。
稳定性：
插入排序是稳定的排序算法，因为在排序过程中相同元素的相对位置不会发生变化。
实现示例（Java）：
以下是一个使用Java实现的插入排序示例：
public class InsertionSort {
public static void insertionSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
int n = arr.length;
for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;
//移动 arr[0..i-1] 中大于键的元素
// 到比他们当前位置领先一个位置
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
insertionSort(arr);
System.out.println("插入排序后的数组 : ");
for (int value : arr) {
System.out.print(value + " ");
}
}
}
希尔排序
定义：
希尔排序（Shell Sort），也称为“缩小增量排序”，是由Donald Shell在1959年提出的。它是插入排序的一种更高效版本，通过引入“增量”概念来改进插入排序的性能。
基本思想：
希尔排序的核心在于将原本需要进行大量交换的插入排序，通过分组和减少比较距离来加速。它首先将整个待排序的记录序列分割成为若干个子序列分别进行直接插入排序，具体做法是，设定一个增量序列t1，t2，…，tk，其中ti > tj，tk = 1；然后，按增量序列个数k，进行k 趟排序；每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅当增量因子减少到1时，整个表才作为一个整体考虑。
基本步骤：
- 选择增量：选择一个递减的增量序列，常见的增量序列有h = [n/2, n/4, …, 1] 或者 h = [1, 4, 13, 40, …]（Hibbard增量）等。
- 分组并排序：按照当前的增量h，将数组分为h个子序列，对每个子序列进行插入排序。
- 减小增量并重复：减小增量，重复步骤2，直到增量为1，此时整个数组被视为一个序列进行排序。
复杂度分析
时间复杂度分析：
最好情况、最坏情况和平均情况：希尔排序的时间复杂度取决于增量序列的选择，不同的增量序列会导致不同的性能表现。在最好的情况下，希尔排序的时间复杂度可以达到接近O(n log n)；而在最坏的情况下，如果增量序列选择不当，时间复杂度可能退化到O(n^2)。
空间复杂度：
希尔排序是原地排序算法，不需要额外的存储空间，因此空间复杂度为O(1)。
稳定性：
希尔排序是不稳定的排序算法，因为在排序过程中，相等的元素可能会由于插入操作而改变它们的相对位置。
实现示例（Java）：
以下是一个使用Java实现的希尔排序示例：
public class ShellSort {
public static void shellSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
int n = arr.length;
int gap = n / 2;
while (gap > 0) {
for (int i = gap; i < n; i++) {
int temp = arr[i];
int j = i;
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
gap /= 2;
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
shellSort(arr);
System.out.println("希尔排序后的结果为 : ");
for (int value : arr) {
System.out.print(value + " ");
}
}
}
归并排序
定义：
归并排序（Merge Sort）是一种有效的、基于比较的排序算法，它使用了分治法（Divide and Conquer）策略来实现高效的排序。归并排序的思想是将数组分成两半，递归地对每一半进行排序，然后将两个有序的子数组合并成一个有序的数组。
基本步骤：
- 分解：如果数组的长度大于1，那么将数组分成两半，递归地对每一半进行归并排序。
- 合并：将两个已排序的子数组合并成一个有序的数组。合并的过程中，比较两个子数组的元素，将较小的元素放入结果数组中，直到一个子数组被完全处理，然后将另一个子数组剩下的元素依次放入结果数组。
归并排序的递归过程：
基本情况：如果数组只有一个元素，那么它已经是排序好的。
递归情况：将数组分成两半，对每一半进行归并排序，然后将两个有序的子数组合并。
复杂度分析
时间复杂度分析：
最好情况、最坏情况和平均情况：归并排序的时间复杂度均为O(n log n)，其中n是数组的长度。这是因为每次分解可以将问题规模减半，而合并操作需要线性时间。
空间复杂度：
归并排序需要额外的空间来存放临时数组，用于合并操作，因此空间复杂度为O(n)。
稳定性：
归并排序是稳定的排序算法，因为在合并过程中，相等的元素会保持它们原有的相对位置。
实现示例（Java）：
下面是一个使用Java实现的归并排序示例：
public class MergeSort {
public static void mergeSort(int[] arr) {
if (arr == null || arr.length <= 1) {
return;
}
mergeSort(arr, 0, arr.length - 1);
}
private static void mergeSort(int[] arr, int left, int right) {
if (left < right) {
int mid = (left + right) / 2;
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
private static void merge(int[] arr, int left, int mid, int right) {
int[] temp = new int[right - left + 1];
int i = left;
int j = mid + 1;
int k = 0;
while (i <= mid && j <= right) {
if (arr[i] <= arr[j]) {
temp[k++] = arr[i++];
} else {
temp[k++] = arr[j++];
}
}
while (i <= mid) {
temp[k++] = arr[i++];
}
while (j <= right) {
temp[k++] = arr[j++];
}
for (int p = 0; p < temp.length; p++) {
arr[left + p] = temp[p];
}
}
public static void main(String[] args) {
int[] arr = {64, 34, 25, 12, 22, 11, 90};
mergeSort(arr);
System.out.println("归并排序后的结果 : ");
for (int value : arr) {
System.out.print(value + " ");
}
}
}