常用排序算法总结

最新推荐文章于 2024-09-10 10:21:38 发布

旦旦君

最新推荐文章于 2024-09-10 10:21:38 发布

阅读量77

点赞数

文章标签：排序算法 java 算法

本文链接：https://blog.csdn.net/qq_28320763/article/details/125255622

版权

本文详细介绍了五种常见的排序算法：冒泡排序、选择排序、插入排序、希尔排序和快速排序，包括它们的原理、代码实现及复杂度分析。冒泡排序和插入排序是稳定的排序算法，而选择排序、希尔排序和快速排序则不稳定。所有排序算法的时间复杂度至少为O(n^2)，但归并排序和快速排序平均情况可达到O(nlogn)。

摘要由CSDN通过智能技术生成

常用排序算法

1、冒泡排序（稳定）

排序原理：

比较相邻的元素。如果前一个元素比后一个元素大，就交换这两个元素的位置。
对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。最终最后位置的元素就是最大值。

/**
 * 冒泡排序 复杂度O(n`2)
 * 稳定
 */
public class BubbleSort {

    public static void main(String[] args) {

        int[] arr = {2, 3, 1, 65, 54, 23, 45};

        bubble(arr);
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

    }

    public static void bubble(int[] arr){

        for(int i = 0; i < arr.length-1; i++){
            //外循环第一次，最大的一个数就会下沉到数组的最后
            //外循环第一次，第二大的一个数就会下沉到数组的倒数第二个位置
            //.......
            for(int j = 0; j < arr.length-i-1; j++){
                if(arr[j] > arr[j+1]){
                    int temp = arr[j+1];
                    arr[j+1] = arr[j];
                    arr[j] = temp;
                }
            }
        }
    }
}

2、选择排序

排序原理：

每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值依次进行比较，如果当前索引处的值大于其他某个索引处的值，则假定其他某个索引出的值为最小值，最后可以找到最小值所在的索引
交换第一个索引处和最小值所在的索引处的值

/**
 * 选择排序 复杂度O(n`2)
 * 不稳定 例如:[5,8,5,2,9]
 */
public class SelectSort {

    public static void main(String[] args) {

        int[] arr = {2, 3, 1, 65, 54, 23, 45};

        int[] select = select(arr);
        for(int i=0; i<select.length; i++){
            System.out.println(select[i]);
        }

    }

    public static int[] select(int[] arr){

        for(int i = 0; i < arr.length-1; i++){
            //每次外循环进行一次，就会把数组中最小的值上浮到数组的第i个位置
            for(int j = i+1; j < arr.length; j++){
                if(arr[i] > arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[i];
                    arr[i] = temp;
                }
            }
        }

        return arr;
    }
}

3、插入排序（稳定）

排序原理：

把所有的元素分为两组，已经排序的和未排序的；
找到未排序的组中的第一个元素，向已经排序的组中进行插入；
倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到找到一个元素小于等于待插入元素，那么就把待插入元素放到这个位置，其他的元素向后移动一位；

/**
 * 插入排序 复杂度O(n`2)
 * 稳定
 */
public class InsertSort {

    public static void main(String[] args) {

        int[] arr = {2, 3, 1, 65, 54, 23, 45};

        insert(arr);
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }
    }

    public static void insert(int[] arr){

        for(int i = 1; i < arr.length; i++){
            for(int j = i; j > 0; j--){
                if(arr[j-1] > arr[j]){
                    int temp = arr[j];
                    arr[j] = arr[j-1];
                    arr[j-1] = temp;
                }else {
                    //跳出内层循环
                    break;
                }
            }
        }
    }
}

4、希尔排序

希尔排序是插入排序的一种，又称缩小增量排序，是插入排序算法的一种更高效的改进版本。

排序原理：

选定一个增长量h，按照增长量h作为数据分组的依据，对数据进行分组；
对分好组的每一组数据完成插入排序；
减小增长量，最小减为1，重复第二步操作。

/**
 * 希尔排序(改进的插入排序) 复杂度O(nlogn)
 * 不稳定
 */
public class ShellSort {

    public static void main(String[] args) {

        int[] arr = {2, 3, 1, 65, 54, 23, 45};

        shell(arr);
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

    }

    public static void shell(int[] arr){

        for (int gap = arr.length/2; gap > 0 ; gap /= 2) {
            for(int i = gap; i < arr.length; i++){
                for(int j = i; j > 0; j -= gap){
                    if(arr[j-gap] > arr[j]){
                        int temp = arr[j];
                        arr[j] = arr[j-gap];
                        arr[j-gap] = temp;
                    }else {
                        //跳出内层循环
                        break;
                    }
                }
            }
        }
    }
}

5、归并排序（稳定）

排序原理：

尽可能将的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子
组的元素个数是1为止。
将相邻的两个子组进行合并成一个有序的大组；
不断的重复步骤2，直到最终只有一个组为止。

/**
 * 归并排序 复杂度O(nlogn)
 * 稳定
 * 采用递归
 * 需要额外的开销空间
 * 采用分而治之的思想
 */
public class MergeSort {

    public static void main(String[] args) {
        int arr[] = {8, 4, 5, 7, 1, 3, 6, 2};
        int[] temp = new int[arr.length];//归并排序需要一个额外空间
        mergeSort(arr, 0, arr.length-1, temp);

        System.out.println(Arrays.toString(arr));
    }

    //分+合方法
    public static void mergeSort(int[] arr, int left, int right, int[] temp){
        if(left < right){
            int mid = (left + right)/2; //中间索引
            //向左递归进行分解
            mergeSort(arr, left, mid, temp);
            //向右递归进行分解
            mergeSort(arr, mid+1, right, temp);
            //合并
            merge(arr, left, mid, right, temp);
        }
    }

    //合并的方法
    /**
     * 合并两个有序的数组
     * @param arr 初始索引
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp
     */
    public static void merge(int[] arr, int left, int mid, int right, int[] temp){

        int i = left; //初始化i, 左边有序序列的初始索引
        int j = mid + 1; //初始化j, 右边有序序列的初始索引
        int t = 0; // 执行temp数组的当前索引

        //先把左右两边(有序)的数据按照规则填充到temp数组
        //直到左右两边的有序序列，有一边处理完毕为止
        while(i <= mid && j <= right){
            //如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素
            //即将左边的当前元素，填充到temp数组
            //然后t++,i++
            if(arr[i] <= arr[j]){
                temp[t] = arr[i];
                t += 1;
                i += 1;
            }else { //反之，将右边有序序列的当前元素，填充到temp数组
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }
        }


        //把剩余数据的一边的数据依次全部填充到temp
        while (i <= mid){ //左边的有序徐磊还有剩余的元素，就全部填充到temp
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }

        while (j <= right){ //右边的有序徐磊还有剩余的元素，就全部填充到temp
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }

        //将temp数组的元素拷贝到arr
        //注意，并不是每次都拷贝所有
        t = 0;
        int tempLeft = left;
        while(tempLeft <= right){
            arr[tempLeft++] = temp[t++];
        }

    }
}

6、快速排序

快速排序是对冒泡排序的一种改进。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序
过程可以递归进行，以此达到整个数据变成有序序列。

排序原理：

首先设定一个分界值，通过该分界值将数组分成左右两部分；
将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处理。
重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。

**
 * 快速排序(改进的冒泡排序) 复杂度O(nlogn)
 * 不稳定
 * 采用递归的思想
 */
public class QuickSort {

    public static void main(String[] args) {

        int[] arr = {2, 3, 1, 65, 54, 23, 45};

        quick(arr, 0, arr.length-1);
        for(int i=0; i<arr.length; i++){
            System.out.println(arr[i]);
        }

    }

    public static void quick(int[] arr, int l, int r){

        if(l < r){
            int i = l, j = r, temp = arr[i];//以第一个数为基准
            while(i < j){
                while(i < j && temp <= arr[j]) //以第一个数为基准，从右到左找小于temp的数
                    j--;
                if(i < j){
                    arr[i] = arr[j];
                    i++;
                }
                while(i < j && temp > arr[i]) // 从左到右在找大于temp的数
                    i++;
                if(i < j){
                    arr[j] = arr[i];
                    j--;
                }
            }
            arr[i] = temp;
            quick(arr, l, i-1); //对以第一个数为基准的左边的部分进行快速排序
            quick(arr, i+1, r); //对以第一个数为基准的右边的部分进行快速排序
        }
    }

}