插入、冒泡、选择、快速排序的简单概述

最新推荐文章于 2024-05-19 16:45:21 发布

清木

最新推荐文章于 2024-05-19 16:45:21 发布

阅读量83

点赞数 2

分类专栏： Java入门文章标签：算法 java 排序算法学习 Powered by 金山文档

本文链接：https://blog.csdn.net/weixin_58545784/article/details/128959520

版权

Java入门专栏收录该内容

20 篇文章 0 订阅

订阅专栏

插入排序（Insertion Sort）

算法步骤

首先从第一个元素开始，该元素被认为是有序的；

取出下一个元素，在已经排序的元素序列中从后往前进行扫描；

如果此时排好序的元素大于新元素，则该元素移到下一个位置；

重复步骤3一直将需要排序的元素往前比较，直到找到已排好序的元素小于或者等于新元素的位置；

将新元素插入到该位置后；

重复步骤2~5。

代码实现：

public static void insertSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            int tmp = arr[i];
            int j = i - 1;
            for (; j >= 0; j--) {
                if (arr[j] > tmp) {
                    arr[j + 1] = arr[j];
                } else {
                    break;
                }
            }
            arr[j + 1] = tmp;
        }
        System.out.println(Arrays.toString(arr));
    }

时间复杂度：

在插入排序中，当待排序列数组是有序时，是最优的情况，只需当前数根下一个数比较，这时一共需要比较N-1次，时间复杂度为 $\text{[math]}$ 。

最坏的情况是待排序列为逆序时，需要比较的次数最多，总次数为： $\text{[math]}$ ，此时插入排序在最坏的情况下的时间复杂度为 $\text{[math]}$ 。

平均情况为： $\text{[math]}$ ，因为一元二次函数比一元一次函数增长的快，所以插入排序的时间复杂度为 $\text{[math]}$ 。

空间复杂度为 $\text{[math]}$ 。

2.冒泡排序（Bubble Sort）

算法步骤

比较相邻的元素，如果第一个比第二个大，就交换它们；

对每一对相邻的元素作同样的比较，从开始的第一队到结尾的最后一对，这样结尾的元素就是最大的。

对所有元素重复上面的步骤，除了已经排好序的元素。

重复1~3，知道排序完成。

代码实现：

public static void bubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //相邻两个数比较
            for (int j = 0; j < arr.length-1-i; j++) {
                if (arr[j]>arr[j+1]) {
                    int temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

最好的时间复杂度

若数组的顺序是正序的，一趟扫描即可完成排序。所需的时间复杂度为 $\text{[math]}$ 。

最坏的时间复杂度

若数组的顺序是反序的，需要进行n-1趟排序，每趟需要n-1次的比较（1<=i<n-1），此时的时间复杂度为 $\text{[math]}$ 。

冒泡排序的时间复杂度为： $\text{[math]}$

冒泡排序在原数组上进行更改，没有开辟新的内存空间，所以它的空间复杂度为： $\text{[math]}$ 。

3.选择排序（Selection Sort）

算法步骤：

首先找到序列中最小元素，存放到排序序列的起始位置。

再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

代码实现：

public static void selectionSort(int[] arr) {
        int len = arr.length;
        int minIndex, temp;
        for (int i = 0; i < len - 1; i++) {
            minIndex = i;
            for (int j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {     // 寻找最小的数
                    minIndex = j;   // 将最小数的索引保存
                }
            }
            temp = arr[i];
            arr[i] = arr[minIndex];
            arr[minIndex] = temp;
        }
        System.out.println(Arrays.toString(arr));
    }

选择排序的最好、最坏、平均的时间复杂度都为 $\text{[math]}$ ，因为无论你是否完全有序，还是完全逆序，都需要找出后面的最小值进行交换。

选择排序也不需要开辟新的内存空间，所以空间复杂度为 $\text{[math]}$ 。

4.快速排序（Quick Sort）

算法步骤：

从数列中挑出一个元素，称为 "基准"（pivot）;

重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

代码实现：

public static void quickSort(int[] arr,int low,int high){
        if (low >= high) {
            return;
        }
        int i = low;
        int j = high;
        int temp = arr[low];
        int t = 0;//用于交换
        while (i < j) {
            //先看右边，依次往左递减
            while (temp <= arr[j] && i < j) {
                j--;
            }
            while (temp >= arr[i] && i < j) {
                i++;
            }
            if (i < j) {
                t = arr[i];
                arr[i] = arr[j];
                arr[j] = t;
            }
        }
        //将基准为与i和j相等位置的数字交换，将数组分为两份
        arr[low] = arr[i];
        arr[i] = temp;
        //递归调用左半数组
        quickSort(arr, low, j-1);
        //递归调用右半数组
        quickSort(arr, j+1, high);
    }

时间复杂度：

最好的情况，选取的轴刚好就是这个区间的中位数，也就是说，在操作之后，正好将区间分成了数字个数相等的左右两个子区间，时间复杂度为： $\text{[math]}$ 。