七种基于比较的排序，基于Java实现，还不点赞收藏？

最新推荐文章于 2024-09-18 09:23:25 发布
最新推荐文章于 2024-09-18 09:23:25 发布
阅读量813 收藏 6
点赞数 3
分类专栏： 数据结构，算法，Mysql 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45704528/article/details/113873477
版权

目录

一.总览

在这里插入图片描述

二.基于比较的排序算法

1.简单插入排序（重点）

注意：区间较小时，最快
原理：
一组数据array[]，认为以下标i为分界，[0，i+1)认为有序，[i+1,array.length)无序，从无序数据中每次取出一个数据，插入有序数据中
在这里插入图片描述
代码实现：

 public static void insertSort(long []array){
        //数据一共有array.length个
        //所以，子操作需要执行array.length次
        //减不减一都可以，减一认为第一个数已经有序
        for (int i = 0; i <array.length-1 ; i++) {
            //有序[0,i+1)  例如刚开始[0,1)有序
            //无序[i+1,array.length)
            //抓取出来的数是[i+1]

            long key=array[i+1];
            int j=0;
            //依次在有序区间进行比较
            for ( j = i; j>=0 ; j--) {
                //[j]就是需要和key比较的数
                /**
                 * key<array[j]   把array[j]往后移 继续往前比较
                 * key==array[j]  把key放入array[j]的后边
                 * key>array[j]   把key放入array[j]的后边
                 */
                if(key<array[j]){
                    array[j+1]=array[j];
                }else {
                    break;
                }
            }
            array[j+1]=key;

        }
    }

性能分析：
在这里插入图片描述

2.冒泡排序（重点）

原理：
在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序
无序区间：[0,array,length-i)
有序区间：[array.length-i,array.length)

从下标j开始，将其与下标j+1依次比较，如果大于，交换。
在这里插入图片描述
代码实现：

public static void bubblingSort(long []array){
    //外层循环，需要多少次冒泡的过程
        for (int i = 0; i <array.length ; i++) {
            //无序区间：[0,array,length-i)
            //有序区间[array.length-i,array.length)

            //假设数组已经有序
            boolean isSorted=true;

            //冒泡过程
            //只在无序区间中进行
            //循环到无序区间的倒数第二个数，然后倒数第二会和倒数第一再比较
            for (int j  = 0; j  <array.length-i-1 ; j ++) {
                if(array[j]>array[j+1]){
                  swap(array, j, j+1);
                  //交换过，说明数组无序
                    isSorted=false;
                }
            }

            //如果数组有序，退出循环
            if(isSorted){
                break;
            }
        }
    }

    public static void swap(long []array,int i,int j){
     long t=array[i];
     array[i]=array[j];
     array[j]=t;
    }

性能分析：
在这里插入图片描述

3.简单选择排序

**原理：
每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素排完 。
以选取最大为例：
无序区间[0,array.length-i)
有序区间[array.length-i,array.length)

动态图为选取最小为例：
在这里插入图片描述

代码实现：

//选择排序

    /**
     *选择大的数
     * 前面为有序区间，后面为无序区间
     * 再无序区间中遍历，找到最大的数，和无序区间的最后一个数进行交换
     */
    public static void selectSort(long[]array){
        //一共多少次选择的过程
        for (int i = 0; i <array.length ; i++) {
            //无序区间：[0,array.length-i)
            //有序区间：[array.length-i,array.length)
            //记录无序区间最后一个值的下标和值
            int maxindex=array.length-i-1;
            long key=array[array.length-i-1];
            for (int j = 0; j <array.length-i ; j++) {
                if(array[j]>key){
                    maxindex=j;
                    key=array[j];
                }
            }
            //期望maxIndex指向无序区间的最大值的下标
            //交换最大数所在下标和无序区间最后一个数的下标
            swap(array, maxindex, array.length-i-1);
        }
    }

    public static void swap(long[]array,int i,int j){
        long t=array[i];
        array[i]=array[j];
        array[j]=t;
    }

性能分析：
在这里插入图片描述

4.堆排序

原理：
基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的数。
注意：排升序要建大堆，排降序要建小堆，否则不行
在这里插入图片描述
代码实现：

public class HeapSort {
    public static void heapSort(long[]array,int size){
       //1.建大堆
          bulidHeap(array,size);
        //2.进行选择的过程，一共需要array.length-1组
        for (int i = 0; i <array.length-1 ; i++) {
            //无序区间：[0,array.length-i)
            //有序区间：[array.length-i,array.length)
            swap(array,0,array.length-i-1);
            //此时无序区间：[0,array.length-i-1)
            //无序区间的个数为array.length-i-1
            adjustDown(array,array.length-i-1,0);
        }
    }
    //交换
    public static void swap(long[]array,int i,int j){
        long t=array[i];
        array[i]=array[j];
        array[j]=t;
    }
    //建大堆
    public static void bulidHeap(long []array,int size){
        int lastNodeIndex=size-1;
        int lastParentIndex=(lastNodeIndex-1)/2;
        for (int i = lastParentIndex; i >=0 ; i--) {
            adjustDown(array,size,i);
        }


    }
    //向下调整
    public static void adjustDown(long[]array,int size,int index){
        while (true){
            //堆是完全二叉树，一定有左孩子
            int leftIndex=index*2+1;
            //如果没有左孩子，则为叶子结点,直接return
            //等于size也超出了数组下标范围
            if(leftIndex>=size){
                return;
            }
            //找最大的孩子
            int maxIndex=leftIndex;
            int rightIndex=leftIndex+1;
            //如果右孩子存在且右孩子的值大于左孩子，则将最大值的下标改为右孩子
            if(rightIndex<size&&array[rightIndex]>array[leftIndex]){
               maxIndex=rightIndex;
            }
            //比较maxIndex和index位置的值，如果maxIndex大，则交换，否则retrun
            if(array[maxIndex]<=array[index]){
                return;
            }
            swap(array, maxIndex, index);
            index=maxIndex;
        }
    }
}

性能分析：
在这里插入图片描述

5.希尔排序

原理：
分组插入排序
希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有
距离为的记录分在同一组内，并对每一组内的记录进行插入排序。然后，取，重复上述分组和排序的工作。当到达=1时，所有记录在统一组内排好序。
步骤：
1.分为gap组，认为gap之前的都是有序的（每组一个数）
2.对分好的每一个组，在组内进行插入排序
在这里插入图片描述
代码实现：

//希尔排序(带间隔的插入排序）
public class ShellSort {
    public static void shellSort(long[]array){
        int gap=array.length/2;

        while (true){
            insertSortWithGap(array, gap);
            if(gap==1){
                break;
            }
            gap=gap/2;
        }
    }


    public static void insertSortWithGap(long[]array,int gap){
        //分为gap组，认为gap之前的都是有序的（每组一个数）
        for (int i =gap; i <array.length ; i++) {
            //记录需要比较的值
          long key=array[i];
          int j=0;
          //对每组的值进行插入排序，每组间隔为gap个
            for (j =i-gap; j >=0 ; j=j-gap) {
                if(key<=array[j]){
                    array[j+gap]=array[j];
                }else {
                    break;
                }
            }
            array[j+gap]=key;
        }
    }
}

性能分析：
在这里插入图片描述

6.快速排序（重点）

原理：
快速排序原理：
在这里插入图片描述
partition分割原理：Hover法
在这里插入图片描述
在这里插入图片描述
步骤：
1.选择一个数key（一般选最左边）
2.做partition分隔（小的放左边，大的放右边）
3.分别做左右两个小区间按相同的方式处理（递归）
4.知道（小区间有序：区间数的个数size<=1)

代码实现：


public class QuickSort {
    public static void quickSort(long[]array){
        //排序的区间为lowIndex到highIndex
        quickSortInteral(array,0,array.length-1);
    }

    private static void quickSortInteral(long[]array,int lowIndex,int highIndex){
        //记录区间内数的个数
        //区间是[lowIndex,highIndex]
        int size=highIndex-lowIndex+1;
        //当区间内个数小于等于一时，区间有序
        if(size<=1){
            return;
        }

        //1.选择其中一个数出来（最左边）->array[lowIndex]
        //2.执行partition（分隔），小的数放左，大的数放右

        //keyIndex是经过partition后，选出来的数的最终下标
        int keyIndex=partitionHover(array,lowIndex,highIndex);

        //keyIndex左边： 左边的lowIndex=lowIndex，highIndex=keyIndex-1
        //keyIndex右边： 右边的lowIndex=keyIndex+1，highIndex=highIndex

        //分别左左右区间相同处理->递归
        quickSortInteral(array, lowIndex, keyIndex-1);
        quickSortInteral(array, keyIndex+1, highIndex);

    }
    //区间为array[lowIndex,highIndex]
    //1.选择array[lowIndex]作为特殊的数
    //2.需要遍历整个区间（不能遗漏任何数），与选择出来的数进行比较
    //3.保证小于等于的在最左边，大于等于的数在最右边（但没有顺序要求）
    private static int partitionHover(long []array,int lowIndex,int highIndex){
       int leftIndex=lowIndex;
       int rightIndex=highIndex;
       //选择的数是最左边的
        //注意：选择最左边的数key，要让rightIndex先动起来，不然右边全小于key的情况不好考虑
        long key=array[lowIndex];
        while (leftIndex<rightIndex){
            while (leftIndex<rightIndex&&array[rightIndex]>=key){
                //当右边的值大于key，rightIndex继续往左走
                rightIndex--;
            }
            while (leftIndex<rightIndex&&array[leftIndex]<=key){
                //当左边的值小于key，leftIndex继续往右走
                leftIndex++;
            }
            //当leftIndex和rightIndex都停下来时，交换
            swap(array, leftIndex, rightIndex);

            //当leftIndex和rightIndex相遇时，循环结束
        }
        //交换开始选中的值leftIndex和上述停止相遇的值lowIndex
        swap(array, leftIndex, lowIndex);

        //返回选中的key值当前的位置
        return leftIndex;

    }

    private static void swap(long[]array,int i,int j){
        long t=array[i];
        array[i]=array[j];
        array[j]=t;
    }
}

性能分析：

在这里插入图片描述
时间复杂度：每次partition的时间为O（n），然后乘以二叉树的高度

7.归并排序（二路归并）（重点）

原理：
归并思想：
在这里插入图片描述
数组合并思想：
创建一个新数组，数组大小个原数组大小相等
遍历将左边和右边两个有序区间，并比较。如同打擂台，小的数放入新数组
最后将新创建的数组复制到原数组即可

整体思想：
在这里插入图片描述
在这里插入图片描述

代码实现：

//归并排序
public class MergeSort {
    public static void mergeSort(long[]array){
        mergeSortInternal(array,0,array.length);

    }

    //区间范围是左闭右开
    //array[lowIndex,highIndex)
    private static void mergeSortInternal(long[] array, int lowIndex, int highIndex) {

        int size=highIndex-lowIndex;
        if(size<=1){
            return;
        }
        int middleIndex=(highIndex+lowIndex)/2;
        //区间被分成左右两份
        //左区间：[lowIndex,middleIndex)
        //右区间: [middleIndex,highIndex)


        //递归
        mergeSortInternal(array, lowIndex, middleIndex);
        mergeSortInternal(array, middleIndex, highIndex);


         //左右两个区间都有序
        mergeLeftAndRight(array,lowIndex,middleIndex,highIndex);


    }

    //合并两个有序区间
    private static void mergeLeftAndRight(long[] array, int lowIndex, int middleIndex, int highIndex) {
        //两个区间数的总数
        int size=highIndex-lowIndex;
        long[]extraArray=new long[size];

        //遍历（三个下标，一个数组一个）
        int leftIndex=lowIndex;
        int rightIndex=middleIndex;
        int extraIndex=0;

        //两个队伍都有人
        while (leftIndex<middleIndex&&rightIndex<highIndex){
            //加等于保证稳定性
            if(array[leftIndex]<=array[rightIndex]){
                extraArray[extraIndex]=array[leftIndex];
                leftIndex++;
            }else {
                extraArray[extraIndex]=array[rightIndex];
                rightIndex++;
            }
            extraIndex++;
        }

        //直到有个队伍没有人
        if(leftIndex<middleIndex){
            //左边队伍有人
            while (leftIndex<middleIndex){
                extraArray[extraIndex++]=array[leftIndex++];
            }
        }else {
            //右边队伍有人
            while (rightIndex<highIndex){
                extraArray[extraIndex++]=array[rightIndex++];
            }
        }

        //最后把数据从extraArray新数组搬回去
        //新数组extraArray[0,size)
        //搬回去的下标范围[lowIndex,highIndex)
        for (int i = 0; i <size; i++) {
            array[i+lowIndex]=extraArray[i];
        }
    }
  
}

性能分析：
在这里插入图片描述

三.性能总结

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

四.jdk中提供的排序方法

在这里插入图片描述

五.海量数据的排序

在这里插入图片描述

Serendipity sn
关注
专栏目录
C语言数据结构的8个排序
weixin_52485836的博客
02-25 1040
排序难点:算法多,容易混淆 1.直接(简单)插入排序:扑克牌 特点:越有序越快,完全有序O(n),非常重要,这个是希尔排序的基础 2.希尔(shell)排序 分组后利用直接插入排序 3.冒泡排序： 两两比较，大的往后走 * 4.快速排序： 算法：1.从后往前找比基准小的数字，找到往前挪 2.从前往后找比基准大的数字，找到往后挪 3.重复1.2 ...
Redis应用：基于Redis实现排行榜、点赞、关注功能
学IT，找陈寒
06-14 996
这些功能在社交媒体、游戏和电商平台中广泛应用，掌握这些技术可以帮助开发者更好地利用 Redis 的强大功能，构建高性能的应用。Redis 的高效数据结构和操作命令，使其成为实现这些功能的理想选择。希望本文能为你在实际开发中提供帮助。如果你有任何问题或建议，欢迎留言讨论。😊🙏Java面试技巧Java面试八股文 - 掌握面试必备知识（目录篇）Java学习路线2023年完整版Java学习路线图AIGC人工智能Chat GPT是什么，初学者怎么使用Chat GPT，需要注意些什么Java实战项目。
直接插入排序、希尔排序、起泡排序、快速排序、简单选择排序、堆排序、二路归并排序
11-16
直接插入排序、希尔排序、起泡排序、快速排序、简单选择排序、堆排序、二路归并排序的C++语言实现，亲测可行，二路归并排序未得到预期结果，望指正。
关于排序，你想要的这都有！{常见的八种基于比较的排序详解（直接插入排序、折半插入排序、希尔排序、直接选择排序、堆排序、冒泡排序、快速排序、归并排序）}
char_m的博客
05-11 1078
排序稳定性插入排序直接插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序归并排序 稳定性 两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性 插入排序 直接插入排序 基于线性表插入元素的方式而演化出来 思路： 1、定义一个变量bound用来划分区间，整个区间被分为有序区间和无序区间 2、再定义一个临时变量用来存放每次在无序区间选择的第一...
排序篇(七大基于比较的排序算法)
最新发布
L2770789195的博客
09-18 995
然后再重新建大堆 直到每个元素都与根节点交换过现在呢 我们先进行建大堆：首先呢 先创建parent child两个变量parent指向最后一棵树的根 child指向最后一棵树的子树 然后依次将每棵树置成大堆即：让child指向子树元素较大的 若child指向位置的元素大于parent处的元素 则交换然后令parent-- 直到parent走到0下标处接下来我们给出上述图片转化为大堆的过程图当child指向超过下标最大值时 siftDown结束展示代码：
❗⭕⭕算法——排序（直接插入，希尔，简单选择，堆排序，冒泡，快排，归并，基数）
qq_31870305的博客
09-18 1026
文章目录1 介绍1.1 八大排序分类1.2 时间复杂度1.3 空间复杂度2 插入排序-直接插入3 插入排序-希尔排序4 选择排序-简单选择排序5 选择排序-堆排序6 交换排序-冒泡排序7 交换排序-快速排序8 归并排序9 基数排序 1 介绍 1.1 八大排序分类 1.2 时间复杂度 图片来自于网络 1.3 空间复杂度 一个算法运行时，临时占用存储空间大小的度量，与解决问题的规模n有关，n较大时，会占用较多存储单元，例如快速排序和归并排序。 主要讨论时间复杂度，更看重执行速度，缓存产品（r
简单选择排序流程图_排序算法：直接插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序，堆排序...
weixin_30358181的博客
01-27 1135
今天来总结一下常用的排序算法。排序算法们需要掌握的知识点大概有：算法的原理，算法的编码实现，算法的时空复杂度的计算和记忆，何时出现最差时间复杂度，以及是否稳定，何时不稳定。目录整体记忆快速排序堆排序建堆时间复杂度推导建堆删除插入堆排序归并排序冒泡排序直接插入排序简单选择排序希尔排序整体记忆名称时间复杂度何时最差是否稳定快速排序平均O(nlogn)，最坏O(n^2)，最好O(nlogn)数...
基于Java+JSP的家庭食谱系统毕业设计实现+源码毕业设计实现+源码.rar
04-20
《基于Java+JSP的家庭食谱系统》是一个典型的Web应用项目，主要利用Java后端技术和JSP（JavaServer Pages）前端技术来构建一个方便用户管理、查找和分享家庭食谱的平台。在这个系统中，用户可以创建自己的食谱库，...
mysql 点赞数据库设计_基于redis实现的点赞功能设计思路详解
weixin_31855625的博客
01-27 4246
点赞其实是一个很有意思的功能。基本的设计思路有大致两种， 一种自然是用mysql等数据库直接落地存储， 另外一种就是利用点赞的业务特征来扔到redis(或memcache)中， 然后离线刷回mysql等。直接写入Mysql直接写入Mysql是最简单的做法。做两个表即可，1、post_like记录文章被赞的次数，已有多少人赞过这种数据就可以直接从表中查到;2、user_like_post记录用户赞过...
基于Vue+SpringCloud博客的设计与实现 有论文
10-02
用户博客中心：发布，更新，删除，评论，点赞，收藏，转发，排行榜已经完成。博客中心是博客的核心，分页和轮滑加载均实现，用Redisson来实现分布式锁控制文章 搜索引擎中心：文章提示信息的增删改查，分页，高亮...
协同过滤推荐算法java_基于用户的协同过滤推荐算法 实现原理及实现代码
weixin_42303282的博客
02-16 5015
基于用户的协同过滤推荐算法实现原理及实现代码基于用户的协同过滤推荐算法实现原理传统的基于用户(User-Based)的协同过滤推荐算法实现原理分四个步骤：1、根据用户历史行为信息构建用户-项目评分矩阵，用户历史行为信息包括项目评分、浏览历史、收藏历史、喜好标签等，本文以单一的项目评分为例，后期介绍其他行为信息和混合行为信息，用户-项目评分矩阵如表1所示：项目1项目2项目3用户A105用户B340用...
七种排序算法（包括直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序）
12-25
七种排序算法（包括直接插入排序，折半插入排序，希尔排序，冒泡排序，快速排序，简单选择排序，归并排序） 还有两道题 1./*设计并实现一个有效的对n个整数重排的算法，使得所有负数位于非负数之前，给出算法的性能分析*/ 2./*试给出一个同时找到n个元素中最大元素与最小元素的有效算法，并说明理由*/
排序算法汇总(选择排序 ,直接插入排序,冒泡排序,希尔排序,快速排序,堆排序)
12-03
排序算法汇总(选择排序 ,直接插入排序,冒泡排序,希尔排序,快速排序,堆排序)
10种排序算法比较（直接插入排序、希尔排序、冒泡排序、快速排序、简单选择排序、堆排序、归并排序、基数排序、折半插入排序、2路插入排序）
热门推荐
Lil Wing
05-30 1万+
本文（所有排序算法代码+综合比较代码）链接： 一、比较目的:        由于《数据结构》课本中各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。所以我希望通过随机数据去比较各种算法的关键字比较次数和关键字移动次数，同时给出实际排序时间，以取得直观的感受。 二、比较内容: 对以下八种常用内部排序算法进行比较：直接插入排序、希...
排序（二）——折半插入排序，希尔排序,冒泡排序
Alihuhu
06-20 867
折半插入排序 #include<stdio.h> #include<stdlib.h> int A[16]={2,5,9,7,6,1,0,8,3,4,15,14,13,11,12,10}; /*输出已排序数组*/ void Print() { int i; for (i = 0; i < 16; i++) { printf(" %d ",A[i]);...
直接插入排序、折半插入排序、希尔排序、冒泡排序、快速排序、选择排序、归并排序--源码
weixin_42706227的博客
04-04 960
直接上源码，有问题请留言： public class Main { public static void main(String[] args) { int[] a={20,30,21,35,2,1}; insert6(a); for(int i=0;i<a.length;i++){ System.out.pr...
基于比较的内排序——温故而知新
weixin_30612769的博客
08-12 131
引言 排序和检索是数据数据的两个关键部分，排序是想尽快有序组织数据，检索则是想尽快查找数据。 最近发现对这个知识点里的部分内容生疏，所以特此做个总结。 环境 IDE：Eclipse 语言：Java 排序分类 排序算法在实现方法上被分为两个大类，我们今天讲的是基于比较的排序算法，非比较算法我们稍后再谈。 几...
算法—比较两种排序算法：选择排序和插入排序（详细）
weixin_30480075的博客
11-15 211
现在我们已经实现了两种排序算法，我们很自然地想知道选择排序和插入排序哪种更快。这里我们第一次用实践说明我们解决这个问题的办法。 性质：对于随机排序的无重复主键的数组，插入排序和选择排序的运行时间是平方级别的，两者之比应该是一个较小的常数。 例证：这个结论在过去的半个世纪中已经在许多不同类型的计算机上经过了验证。在1980年本书第一版完成之时插入排序就比选择排序快一倍，现在仍然是这样，尽管那时这...
七大基于比较的排序
qq_44929652的博客
09-29 192
1.直接选择排序：分为有序区间和无序区间，把无序区间的第一个元素与有序区间里的书比较，并放入合适的位置 public class Sort { //直接插入排序 public static void insertSort(int[] array){ for(int i=1;i<array.length;i++){ //有序[0,i) ...
基于SpringBoot的Java学习社区功能实现
本项目名为“zhong_dawei-community-master_java_”，是一个基于Java语言开发的学习社区应用。该项目通过SpringBoot框架来实现，涵盖了学习社区中常见的一系列功能，包括但不限于用户登录注册、帖子发布与评论、点赞...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Serendipity sn

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值