【数据结构与算法 | 第一篇】七大排序算法总结（冒泡、选择、插入、归并、快速、希尔、堆排序）-CSDN博客

本文链接：https://blog.csdn.net/weixin_61440595/article/details/137544037

在这里插入图片描述

文章目录

七大排序算法总结
1.冒泡排序
2.选择排序
3.插入排序
4.二分插入排序
5.归并排序
6.快速排序
7.希尔排序
8.堆排序（重要）
9.总结

七大排序算法总结

经总结，排序算法大体可以分为以下七大种（含核心思想）：
1. 冒泡排序：通过相邻元素的比较和交换来将最大（或最小）的元素逐渐“冒泡”到数组的一端
2. 选择排序：在未排序部分的数据中选择最小（或最大）的元素，然后将其放置到已排序部分的末尾
3. 插入排序：将待排序的元素逐个插入到已排序部分的正确位置
4. 归并排序：采用分治法，将已有序的子序列合并，得到完全有序的序列；
5. 快速排序：通过选取基准元素，将数组划分为两个子数组，并对子数组递归排序，实现整个数组的快速排序
6. 希尔排序：通过较大间隔的插入排序来使数组中的元素局部有序，从而减少后续插入排序的工作量
7. 堆排序：将待排序的元素构建成一个最大堆（大顶堆或最小堆），然后将堆顶元素与堆的最后一个元素交换，然后重新调整堆，使得剩余的元素仍然构成一个最大堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了

1.冒泡排序

核心思想： 通过相邻元素的比较和交换来将最大（或最小）的元素逐渐“冒泡”到数组的一端
具体步骤：
1. 从数组的第一个元素开始，依次比较相邻的两个元素。
2. 如果前一个元素大于后一个元素，则交换它们的位置，使得较大的元素“冒泡”到后面。
3. 继续进行相邻元素的比较和交换，直到数组的末尾。
4. 重复执行上述步骤，每次都会将当前未排序部分的最大元素“冒泡”到数组的末尾。
5. 重复执行上述步骤，直到整个数组排序完成。

实现代码：

public static void bubbleSort(int[] arr) {
     
    int temp = 0;
    for (int i = arr.length - 1; i > 0; i--) {
      	// 每次需要排序的长度
        for (int j = 0; j < i; j++) {
      			// 从第一个元素到第i个元素
            if (arr[j] > arr[j + 1]) {
     			// 确保较大的元素排到后面
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

时间和空间复杂度：
- 平均情况：O(n2)
- 最好情况：O(n)
- 最坏情况：O(n2)
- 空间复杂度：O(1)
- 稳定性：稳定

优化： 增加标记符swap，用于确定当前一轮冒泡是否有元素进行交换，若没有则跳出循环，表示数组已经有序了

public static void bubbleSort(int[] arr) {
     
    int temp = 0;
    boolean swap;
    for (int i = arr.length - 1; i > 0; i--) {
      // 每次需要排序的长度
        swap=false;
        for (int j = 0; j < i; j++) {
      // 从第一个元素到第i个元素
            if (arr[j] > arr[j + 1]) {
     
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
                swap=true;
            }
        }//loop j
        if (swap==false){
     			//前面的一轮循环没有进行交换，数组已经有序
            break;
        }
    }//loop i
}// method bubbleSort

2.选择排序

核心思想： 在未排序部分的数据中选择最小（或最大）的元素，然后将其放置到已排序部分的末尾
具体步骤：
1. 遍历数组，将第一个元素作为当前最小（或最大）元素。
2. 在未排序部分的剩余元素中，找到最小（或最大）的元素，并记录其位置。
3. 将找到的最小（或最大）元素与未排序部分的第一个元素交换位置，将其放置到已排序部分的末尾。
4. 重复执行上述步骤，每次都会将当前未排序部分的最小（或最大）元素放置到已排序部分的末尾。
5. 这样，经过n-1轮的遍历和交换，整个数组就会按照升序（或降序）排列。

实现代码：

public static void selectionSort(int[] arr) {
     
    int temp, min = 0;
    for (int i = 0; i < arr.length - 1; i++) {
     
        min = i;
        // 循环查找最小值
        for (int j = i + 1; j < arr.length; j++) {
     
            if (arr[min] > arr[j]) {
     
                min = j;
            }
        }
        if (min != i) {
     
            temp = arr[i];
            arr[i] = arr[min];
            arr[min] = temp;
        }
    }
}