数据结构-排序

排序

排序的定义

将序列对象根据某个关键字进行排序。

术语说明

• 稳定：如果a原本就在b前面，且a=b，排序后a仍然在b前面；
• 不稳定：如果a原本就在b前面，且a=b，排序后a可能出现在b后面；
• 内排序：所有排序操作都在内存中完成；
• 外排序：由于数据太大，因此将数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
• 时间复杂度：一个算法执行所消耗的时间；
• 空间复杂度：运行完一个程序所需要的内存大小；

常见的十种算法

排序算法	时间复杂度（平均）	时间复杂度（最坏）	时间复杂度（最好）	空间复杂度	排序方式	稳定性
冒泡排序	O(n²)	O(n²)	O(n)	O(1)	In-place	稳定
选择排序	O(n²)	O(n²)	O(n²)	O(1)	In-place	不稳定
插入排序	O(n²)	O(n²)	O(n)	O(1)	In-place	稳定
希尔排序	O(n¹·³)	O(n²)	O(n)	O(1)	In-place	不稳定
归并排序	O(n log₂n)	O(n log₂n)	O(n log₂n)	O(1)	Out-place	稳定
快速排序	O(n log₂n)	O(n²)	O(n log₂n)	O(1)	In-place	不稳定
堆排序	O(n log₂n)	O(n log₂n)	O(n log₂n)	O(1)	In-place	不稳定
计数排序	O(n + k)	O(n + k)	O(n + k)	O(k)	Out-place	稳定
桶排序	O(n + k)	O(n²)	O(n)	O(n + k)	Out-place	稳定
基数排序	O(n * k)	O(n * k)	O(n * k)	O(n + k)	Out-place	稳定

• n：数据规模
• k：”桶“的个数
• In-place：占用常数内存，不占用额外内存
• Out-place：占用额外内存

常见算法分类

• 按照内部排序和外部排序

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-pKchoS4D-1663982553775)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20220810214924433.png)]

• 按照非线性时间比较类排序和线性时间非比较类排序
  • **非线性时间比较类排序：**通过比较来决定元素间的相对次序，由于其时间复杂度不能突破O(n log₂n)，因此称为非线性时间比较类排序
  • **线性时间非比较类排序：**不能通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此称为线性时间非比较类排序。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TmeH67Ii-1663982553776)(C:\Users\lenovo\AppData\Roaming\Typora\typora-user-images\image-20220810215834276.png)]

冒泡排序

定义

• 通过重复走访过要排序的数列，一次比较两个元素，如果顺序错误就把它们交换过来；最简单的排序算法。

实现原理

• 步骤1：比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 步骤2：对每一对相邻元素进行同样的工作，一直到结尾，那么最后的元素为最大的数；
• 步骤3：针对所有的元素重复步骤，除了每次的最后一个；
• 步骤4：重复步骤1~3。

动画演示

代码实现

* Created with IntelliJ IDEA.
 *
 * @Author: 柒木Cat
 * @Date: 2022/08/10/22:15
 * @Description:
 */
public class BubbleSort {
    /**
     * 冒泡排序
     * @param arr 待排序数组
     */
    public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int[] arr = {11,34,1,5,34,78,32,5};
        bubbleSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

结果

选择排序

定义

• 首先在未排序的序列中找到最小（大）的元素，存放到排序序列的起始位置，然后再从剩余未排序元素中继续寻找最小（大）的元素。然后放在已排序序列的末尾，以此类推，直到所有的元素均排序完成。

实现原理

n个记录的直接选择排序可经过n-1趟直接选择排序得到有序结果。具体算法描述如下：

• 步骤1：初始状态：无序区为R[1…n]，有序区为空；
• 步骤2：第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
• 步骤3：n-1趟结束，数组有序化了。

动画演示

代码实现

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 柒木Cat
 * @Date: 2022/08/10/22:29
 * @Description:
 */
public class SelectionSort {
    /**
     * 选择排序
     */
    public static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[minIndex]) {
                    minIndex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
    }
    
    public static void main(String[] args) {
        int[] arr = {11,34,1,5,34,78,32,5};
        selectionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

结果

插入排序

定义

• 插入排序的工作原理是通过构建有序序列，对于未排序数据，在已排序中从后向前扫描，并找到相应位置插入。插入排序在实现上，通常采用in-place排序，所以是从后向前扫描，在这个过程中，需要反复把已排序元素逐步向后挪位，为新元素提供插入空间。

实现原理

• 步骤1: 从第一个元素开始，该元素可以认为已经被排序；
• 步骤2: 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 步骤3: 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 步骤4: 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 步骤5: 将新元素插入到该位置后；
• 步骤6: 重复步骤2~5。

动画演示

代码实现

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: 柒木Cat
 * @Date: 2022/08/10/23:01
 * @Description:
 */
public class InsertionSort {
    /**
     * 插入排序
     */
    public static void insertionSort(int[] arr) {
        for (int i = 1; i < arr.length; i++) {
            int temp = arr[i];
            int j = i - 1;
            while (j >= 0 && arr[j] > temp) {
                arr[j + 1] = arr[j];
                j--;
            }
            arr[j + 1] = temp;
        }
    }

    public static void main(String[] args) {
        int[] arr = {11,34,1,5,34,78,32,5};
        insertionSort(arr);
        for (int i = 0; i < arr.length; i++) {
            System.out.print(arr[i] + " ");
        }
    }
}

结果

ing[] args) {
int[] arr = {11,34,1,5,34,78,32,5};
insertionSort(arr);
for (int i = 0; i < arr.length; i++) {
System.out.print(arr[i] + " ");
}
}
}

##### 结果
![在这里插入图片描述](https://img-blog.csdnimg.cn/f7455083b24e44439896ef31bd4d5ca6.png)