8大排序算法

最新推荐文章于 2024-08-22 20:46:59 发布
最新推荐文章于 2024-08-22 20:46:59 发布
阅读量319 收藏 1
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 数据结构 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42665745/article/details/119183373
版权

文章目录

时间复杂度

时间频度：一个算法中的语句执行次数称为语句频度或时间频度，记为 T(n)

在计算机科学中，时间复杂性，又称时间复杂度，算法的时间复杂度是一个函数，它定性描述该算法的运行时间。

一般情况下，算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数，用 T(n)表示，若有某个辅
助函数 f(n)，使得当 n 趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称 f(n)是 T(n)的同数量级函数。
记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。

1.冒泡排序

时间复杂度：O(n²)

冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较
相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。

优化：
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在
排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。

public class BubbleSort {
    public static void main(String[] args) {

        //int arr[] = {3, 9, -1, 10, -2};

        //创建80000个数据测试性能
        int arr[]=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*8000000);
        }

        //System.out.println(Arrays.toString(arr));
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date1);

        bubbleSort(arr);
        //System.out.println(Arrays.toString(arr));
        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date2);

    }

    public static void bubbleSort(int[] arr){
        int temp;//临时变量
        Boolean flag=false;//结束标记
        for (int i = 0; i < arr.length-1; i++) {

            for (int j = 0; j < arr.length-1-i; j++) {
                //前面的比后面的大就交换
                if (arr[j]>arr[j+1]){
                    flag=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }

            //如果某趟排序一次也没交换，则结束
            if (!flag){
                break;
            }else {
                flag=false;
            }
        }
    }
}

结果：大概11s
在这里插入图片描述

2.选择排序

选择排序基本思想是：第一次从 arr[0]~arr[n-1]中选取最小值，与 arr[0]交换，第二次从 arr[1]~arr[n-1]中选取最小值，与 arr[1]交换，第三次从 arr[2]~arr[n-1]中选取最小值，与 arr[2]交换，…，第 i 次从 arr[i-1]~arr[n-1]中选取最小值，与 arr[i-1]交换，…, 第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2]交换，总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。
在这里插入图片描述

在这里插入图片描述

public class SelectSort {

    public static void main(String[] args) {

        //int [] arr = {101, 34, 119, 1, -1, 90};

        //创建80000个数据测试性能
        int arr[]=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*8000000);
        }

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date1);

        selectSort(arr);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date2);
    }

    public static void selectSort(int[] arr){

        for (int i = 0; i < arr.length-1; i++) {
            int minIndex=0;//最小值索引
            int min=arr[i];//假设是最小值
            for (int j = 0+i+1; j <arr.length ; j++) {
                if (min>arr[j]){
                    minIndex=j;//改变最小值索引
                    min=arr[j];//改变最小值
                }
            }

            if (minIndex!=0){//最小值索引不是0，才排序，否则代表已经是顺序的
                arr[minIndex]=arr[i];
                arr[i]=min;
            }
            
        }
    }
}

结果：大概3s
在这里插入图片描述

3.插入排序

插入排序（Insertion Sorting）的基本思想是：把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有
序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排
序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表

在这里插入图片描述

public class InsertSort {

    public static void main(String[] args) {

        //int[] arr = {101, 34, 119, 1, -1, 89};
        //创建80000个数据测试性能
        int arr[]=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*8000000);
        }
        
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date1);

        insertSort(arr);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date2);
    }

    public static void insertSort(int[] arr){

        for (int i = 1; i < arr.length; i++) {
            int insertVal=arr[i];//待插入的值
            int insertIndex=i-1;//从待插入值的前一个位置开始比较
            //1.insertIndex>=0 防止下标越界
            //2.insertVal<arr[insertIndex] 还没找到插入位置
            while(insertIndex>=0 && insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];//向后移动1个元素
                insertIndex--;
            }

            //插入
            arr[insertIndex+1]=insertVal;
        }

    }
}

结果：大概1s
在这里插入图片描述

4.希尔排序

希尔排序是希尔（Donald Shell）于 1959 年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序法基本思想：希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含
的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止

在这里插入图片描述

  1. 希尔排序时， 对有序序列在插入时采用交换法, 并测试排序速度.
  2. 希尔排序时， 对有序序列在插入时采用移动法, 并测试排序速度
public class ShellSort {
    public static void main(String[] args) {
        //int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        //创建80000个数据测试性能
        int arr[]=new int[80000];
        for (int i=0;i<80000;i++){
            arr[i]=(int)(Math.random()*8000000);
        }

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date1);

        //shellSort(arr);
        shellSort2(arr);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是："+date2);
    }

    /**
     * 交换法
     *
     * @param arr
     */
    public static void shellSort(int[] arr) {
        int temp = 0;
        int count = 0;

        //增量gap，并逐步缩小增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                // 遍历各组中所有的元素(共 gap 组，每组有个元素), 步长 gap
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        //交换法
                        temp = arr[j + gap];
                        arr[j + gap] = arr[j];
                        arr[j] = temp;
                    }
                }
            }
        }
    }

    /**
     * 移动法
     *
     * @param arr
     */
    public static void shellSort2(int[] arr) {
        // 增量 gap, 并逐步的缩小增量
        for (int gap = arr.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                int j = i;
                int temp = arr[j];
                if (arr[j] < arr[j - gap]) {
                    while (j - gap >= 0 && temp < arr[j - gap]) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
        }
    }
}

交换法结果：大概7s
移动法结果：大概1s

5.快速排序

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

在这里插入图片描述

public class QuickSort {
    public static void main(String[] args) {
        //int[] arr = {-9,78,0,23,-567,70, -1,900, 461};
        //创建80000个数据测试性能
        int arr[] = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }

        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date1);

        quickSort(arr, 0, arr.length - 1);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date2);
    }


    public static void quickSort(int[] arr, int left, int right) {
        int l = left;//左指针
        int r = right;//右指针
        int mid = arr[(left + right) / 2];

        while (l < r) {
            //在 pivot 的左边一直找,找到大于等于 pivot 值,才退出
            while (arr[l] < mid) {
                l += 1;
            }
            //在 pivot 的右边一直找,找到小于等于 pivot 值,才退出
            while (arr[r] > mid) {
                r -= 1;
            }

            //如果 l >= r 说明 pivot 的左右两的值，已经按照左边全部是
            //小于等于 pivot 值，右边全部是大于等于 pivot 值
            if (l >= r) {
                break;
            }

            //交换
            int temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;

            //如果交换完后，发现这个 arr[l] == pivot 值 相等 r--， 前移
            if(arr[l] == mid) {
                r -= 1;
            }
            //如果交换完后，发现这个 arr[r] == pivot 值 相等 l++， 后移
            if(arr[r] == mid) {
                l += 1;
            }
        }

        // 如果 l == r, 必须 l++, r--, 否则为出现栈溢出
        if (l == r) {
            l += 1;
            r -= 1;
        }

        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }

        //向右递归
        if (right > l) {
            quickSort(arr, l, right);
        }
    }
}

结果：1s左右
在这里插入图片描述

6.归并排序

归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）
策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修
补"在一起，即分而治之)。

归并排序思想示意图 1-基本思想:

在这里插入图片描述
归并排序思想示意图 2-合并相邻有序子序列:

在这里插入图片描述

public class MergeSort {
    public static void main(String[] args) {
        //int arr[] = { 8, 4, 7, 5, 1, 3, 6, 2 };

        //创建80000个数据测试性能
        int arr[] = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }
        int temp[]=new int[arr.length];
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date1);

        mergeSort(arr,0,arr.length-1,temp);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date2);

    }

    /**
     * 分治+合并
     * @param arr 原素组
     * @param left 第一个元素索引
     * @param right 最后一个元素索引
     * @param temp  中间数组
     */
    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;//左边有序集合的索引
        int j = mid + 1;//右边有序集合的索引
        int t = 0;//临时集合的索引

        while (i <= mid && j <= right) {
            //1.进行比较，放小的到temp数组
            if (arr[i] < arr[j]) {//左<右，放左边的数据
                temp[t] = arr[i];
                t += 1;
                i += 1;
            } else {//右<左，放右边的数据
                temp[t] = arr[j];
                t += 1;
                j += 1;
            }

        }

        //2.当一边集合放完了，把另一边的集合按顺序放过去
        while (i <= mid) {//左侧有剩余，右侧已经放完了
            temp[t] = arr[i];
            t += 1;
            i += 1;
        }

        while (j <= right) {
            temp[t] = arr[j];
            t += 1;
            j += 1;
        }

        //3.将temp数组的数据拷贝到arr中
        t=0;
        int tempLeft=left;
        //第一次合并 tempLeft = 0 , right = 1 // tempLeft = 2 right = 3 // tL=0 ri=3
        //最后一次 tempLeft = 0 right = 7
        while (tempLeft<=right){
            arr[tempLeft]=temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

结果：大概1s
在这里插入图片描述

7.基数排序

  1. 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶排序”（bucket sort），顾
    名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
  2. 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
  3. 基数排序(Radix Sort)是桶排序的扩展
  4. 基数排序是 1887 年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个
    位数分别比较。

基本思想：将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。
这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。

在这里插入图片描述
在这里插入图片描述

public class RadixSort {
    public static void main(String[] args) {
        //int arr[] = { 53, 3, 542, 748, 14, 214};
        //创建80000个数据测试性能
        int arr[] = new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000);
        }
        int temp[] = new int[arr.length];
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yy-MM-dd HH:mm:ss");
        String date1 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date1);

        radixSort(arr);

        String date2 = simpleDateFormat.format(new Date());
        System.out.println("排序前的时间是：" + date2);
    }

    public static void radixSort(int[] arr) {

        //取最大值的位数
        int max = arr[0];//假设第一数就是最大数
        for (int x = 0; x < arr.length; x++) {
            if (arr[x] > max) {
                max = arr[x];
            }
        }
        //得到最大数是几位数
        int maxLength = (max + "").length();

        //定义一个二维数组，表示 10 个桶, 每个桶就是一个一维数组
        //说明
        //1. 二维数组包含 10 个一维数组
        //2. 为了防止在放入数的时候，数据溢出，则每个一维数组(桶)，大小定为 arr.length
        //3. 基数排序是使用空间换时间的经典算法
        int[][] bucket = new int[10][arr.length];

        //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
        //可以这里理解
        //比如：bucketElementCounts[0] , 记录的就是 bucket[0] 桶的放入数据个数
        int[] bucketElementCounts = new int[10];

        for (int i = 0, n = 1; i < maxLength; i++, n *= 10) {
            //遍历数组按个位放入桶中(第一次是按个位，第二次是十位，第三次是百位..)
            for (int j = 0; j < arr.length; j++) {
                //取出每个元素的对应位的值
                int digitOfElement = arr[j] / n % 10;
                //放入到对应的桶中
                bucket[digitOfElement][bucketElementCounts[digitOfElement]] = arr[j];
                //记录这个桶中放了几个元素
                bucketElementCounts[digitOfElement]++;
            }

            //按照桶的顺序依次取出元素放入数组中
            int index = 0;
            for (int k = 0; k < bucketElementCounts.length; k++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[k] != 0) {
                    //循环该桶即第 k 个桶(即第 k
                    for (int l = 0; l < bucketElementCounts[k]; l++) {
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                //第 i+1 轮处理后，需要将每个 bucketElementCounts[k] 清空
                bucketElementCounts[k] = 0;
            }
        }
    }
}

结果：大概1s
在这里插入图片描述
基数排序说明：

  1. 基数排序是对传统桶排序的扩展，速度很快.
  2. 基数排序是经典的空间换时间的方式，占用内存很大, 当对海量数据排序时，容易造成 OutOfMemoryError 。
  3. 基数排序时稳定的。[注:假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些
    记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且 r[i]在 r[j]之前，而在排序后的序列中，r[i]仍在 r[j]之前，
    则称这种排序算法是稳定的；否则称为不稳定的]
  4. 有负数的数组，我们不用基数排序来进行排序, 如果要支持负数，参考: https://code.i-harness.com/zh-CN/q/e98fa9

8.堆排序

常用排序算法对比

在这里插入图片描述
术语解释：

稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度： 一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。
n: 数据规模
k: “桶”的个数
In-place: 不占用额外内存
Out-place: 占用额外内存

Filwaod
关注
专栏目录
八大排序算法
04-04
八大排序算法精讲,十分全面的工具书，对初学者很适用。
Java常用排序算法程序员必须掌握的8大排序算法
最新发布
09-13
冒泡排序--Java常用排序算法程序员必须掌握的8大排序算法
【数据结构】八大排序
2203_76003626的博客
08-22 2176
八大排序
面试时写不出排序算法？看这篇就够了。
weixin_33811961的博客
04-17 208
本文主要详细讲述常见的八种排序算法的思想、实现以及复杂度。 :notebook: 本文已归档到：「blog」 :keyboard: 本文中的示例代码已归档到：「algorithm-tutorial」 冒泡排序 要点 冒泡排序是一种交换排序。 什么是交换排序呢？ 交换排序：两两比较待排序的关键字，并交换不满足次序要求的那对数，直到整个表都满足次序要求为止。 算法思想 它重复地走访过要排序的数...
Java常用排序算法&程序员必须掌握的8大排序算法+二分法查找
08-03
本资料包聚焦于"Java常用排序算法"和"程序员必须掌握的8大排序算法"，并深入探讨了"二分法查找"这一高效搜索技术。 首先，我们来看八大排序算法。这些算法包括： 1. **冒泡排序**：最简单的排序方法，通过不断交换...
Java常用排序算法程序员必须掌握的8大排序算法Java开
11-22
这8大排序算法包括：冒泡排序、插入排序、选择排序、快速排序、归并排序、堆排序、希尔排序以及桶排序。 1. **冒泡排序**： 冒泡排序是最基础的排序算法，通过不断交换相邻两个未排序元素的位置，逐步将最大（或...
最经典的8大排序算法总结
10-30
在本篇总结中，将探讨8种经典的排序算法，分别是冒泡排序、选择排序、插入排序、快速排序、归并排序、堆排序、二叉树排序和基数排序。 1. 冒泡排序（Bubble Sort）： 冒泡排序是一种简单的排序算法。它重复地遍历要...
java实现8大排序算法
04-26
本资源“java实现8大排序算法”涵盖了常见的排序方法，对于理解这些算法的工作原理以及在实际编程中应用它们非常有帮助。 1. **冒泡排序（Bubble Sort）**：冒泡排序是最简单的排序算法之一，通过不断交换相邻的...
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
Xpccccc的博客
10-13 5720
八大排序算法(含时间复杂度、空间复杂度、算法稳定性)
八大基本排序算法
我欲修仙
10-05 446
算法链接  http://blog.csdn.net/pzhtpf/article/category/944525
Java程序员必知的8大排序算法详解
"这篇资源主要介绍了程序员在IT行业中常用的八大排序算法，包括插入排序、交换排序、选择排序、归并排序以及分配排序中的基数排序。这些排序算法是编程基础中的重要组成部分，尤其对于Java开发者来说，理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值