Java排序实现---代码书写，解释

最新推荐文章于 2024-03-30 15:21:49 发布
最新推荐文章于 2024-03-30 15:21:49 发布
阅读量243 收藏
点赞数
分类专栏： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_45303865/article/details/109654885
版权
本文详细介绍了Java中七种常见的排序算法：直接插入排序、希尔排序、选择排序、堆排序、快速排序（包括优化）、冒泡排序和归并排序。每种排序算法都提供了代码实现，帮助读者理解其工作原理。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

java排序

前言

1.排序：排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。
平时的上下文中，如果提到排序，通常指的是排升序。
2. 稳定性（重要）
两个相等的数据，如果经过排序后，排序算法能保证其相对位置不发生变化，则我们称该算法是具备稳定性的排序算法。
例如：
在这里插入图片描述

提示：
在这里插入图片描述

一、直接插入排序

整个区间被分为

  1. 有序区间
  2. 无序区间
    每次选择无序区间的第一个元素，在有序区间内选择合适的位置插入

1.代码实现

代码如下（示例）：

/**直接插入排序：       空间复杂度：o（1）     //稳定性：稳定    （不见隔交换一定是稳定）
     *时间复杂度：  最坏：o（n^2）即数组无序   最好:o（n）  即本身就有序
     * 特点：越有序    越快（时间效率越高）
     * 也可采用二分法优化
    */
    public static void  insertSort(int[] elem){
        for (int i = 1; i <elem.length ; i++) {
          int  tmp=elem[i];
            int j = i-1;
            for (; j >=0 ; j--) {
                if (elem[j]>tmp){
                    elem[j+1]=elem[j];
                }else{
                    break;
                }
            }
            elem[j+1]=tmp;
        }
    }

二、希尔排序

希尔排序法又称缩小增量法。希尔排序法的基本思想是：先选定一个整数，把待排序文件中所有记录分成个组，所有 距离为的记录分在同一组内，并对每一组内的记录进行排序。然后，取，重复上述分组和排序的工作。当到达=1时， 所有记录在统一组内排好序。 1. 希尔排序是对直接插入排序的优化。

1.代码实现

代码如下（示例）：

/**希尔排序     思想：大分小   小内排序   再缩小增量
     *稳定性：不稳定
     * 空间复杂度：o（1）
     * 时间复杂度：  o（n^1.3）---o（n^1.5）
     * 增量注意事项：值没有除1外的公因子（素数），最后一个增量值一定是1
     */
    public  static  void  shell(int [] elem,int gap){
        for (int i = gap; i <elem.length ; i++) {
            int  tmp=elem[i];
            int j = i-gap;
            for (; j >=0 ; j=j-gap) {
                if (elem[j]>tmp){
                    elem[j+gap]=elem[j];
                }else{
                    break;
                }
            }
            elem[j+gap]=tmp;
        }
    }
    public static void shellSort(int [] array){
        int [] drr={5,3,1};  //增量数组
        for (int i = 0; i <drr.length ; i++) {
                shell(array,drr[i]);
        }
    }

三、选择排序

每一次从无序区间选出最大（或最小）的一个元素，存放在无序区间的最后（或最前），直到全部待排序的数据元素
排完 。

1.代码实现

代码如下（示例）：

/**选择排序
     * 时间复杂度：o（n^2）    空间复杂度：o（1）
     * 稳定性：不稳定
     */
    public  static  void selectSort(int[] array){
        for (int i = 0; i < array.length; i++) {
            for (int j = i+1; j <array.length; j++) {
                if(array[i]>array[j]) {
                    int tmp =array[j];
                    array[i]=array[j];
                    array[j]=tmp;
                }
            }
        }
    }

四、堆排序

基本原理也是选择排序，只是不在使用遍历的方式查找无序区间的最大的数，而是通过堆来选择无序区间的最大的
数。
注意： 排升序要建大堆；排降序要建小堆

1.代码实现

代码如下（示例）：

/**堆排序
     * 时间复杂度：o(n*logn)      空间复杂度：o(1)
     * 稳定性：不稳定
     */
    public static void adjustDown(int []elem,int parent, int len){
        int child = 2*parent+1;
        //1.判断是不是有左孩子
        while (child<len){
            //2.是否有有孩子，有child保存左右孩子的最大值的下标
            if (child+1<len && elem[child]<elem[child+1]){
                child++;
            }
            //child就是最大值的下标
            if (elem[child] > elem[parent]){
                int tmp = elem[child];
                elem[child]= elem[parent];
                elem[parent]=tmp;
                parent =child;
                child=2*parent+1;
            }else{
                break;
            }
        }
    }
     //建堆
    public  static void createHeap(int[] array){
        for (int i = (array.length-1-1)/2; i >=0 ; i--) {
            adjustDown(array,i,array.length);
        }
    }
    public static void heapSort(int[] array){
        createHeap(array);
        int end = array.length-1;
        while (end>0){
            int tmp = array[0];
            array[0]= array[end];
            array[end]=tmp;
            adjustDown(array,0,end);
            end--;
        }
    }

五、快速排序

原理-总览

  1. 从待排序区间选择一个数，作为基准值(pivot)；
  2. Partition: 遍历整个待排序区间，将比基准值小的（可以包含相等的）放到基准值的左边，将比基准值大的（可
    以包含相等的）放到基准值的右边；
  3. 采用分治思想，对左右两个小区间按照同样的方式处理，直到小区间的长度 == 1，代表已经有序，或者小区间
    的长度 == 0，代表没有数据。

1.代码实现

代码如下（示例）：

/**快速排序     找基准，分而治之
     * 时间复杂度：o(n*logn)      空间复杂度：o（log n）
     * 稳定性：不稳定
     */

    private static int partion(int[] array, int start, int end) {
       int tmp =array[start];
        while (start<end){
            while (start<end && array[end]>=tmp){
                end--;
            }
            if (start>=end){
                //array[start]= tmp;
                break;
            }else{
                //此时end值小于tmp，交换
                array[start]=array[end];
            }


            //接着start向后走，找比tmp大的值
            while (start<end && array[start]<=tmp){
                start++;
            }
            //当start》end时，即有序
            if (start>=end){
                //array[start]= tmp;
                break;
            }else {
                //此时start值大于tmp，交换
                array[end]=array[start];
            }
        }
        array[start]= tmp;
        return start;
    }
    //快排核心
    private static void quick(int[] array, int low, int high) {
        //结束条件   （当=时即只有一个数据）
        if (low>=high){
            return;
        }
        //找一次基准
        int par=partion(array,low,high);
        //左治
        quick(array,low,par-1);
        //右治
        quick(array,par+1,high);

    }

    public static void quickSort(int[] array){
        quick(array,0,array.length-1);
    }

快速排序优化

  1. 对于基准的选择，当每次的基准都能使得段内左右都有元素时，速率会更快。而上述代码的基准一直是段的起始位置！！
    解决：（1）随机在段内选取一个下标的值与起始值交换，当作基准（考验人品，有时会效率更差，不推荐）
    (2)三数取中：使low，mid，high满足array[mid]<array[low]<array[high],即每次mid左右都有值！
    2.当段内数据长度小于某个数时，可直接进行直接插入排序。

2.优化代码实现

代码如下（示例）：

public static void swap1(int[] array, int low, int high) {
        int t = array[low];
        array[low] = array[high];
        array[high] = t;
    }
    public static void  insertSort2(int[] elem,int low,int high){
        for (int i = low+1; i <=high ; i++) {
            int  tmp=elem[i];
            int j = i-1;
            for (; j >= low ; j--) {
                if (elem[j]>tmp){
                    elem[j+1]=elem[j];
                }else{
                    break;
                }
            }
            elem[j+1]=tmp;
        }
    }

    private static int partion(int[] array, int start, int end) {
        int tmp =array[start];
        while (start<end){
            while (start<end && array[end]>=tmp){
                end--;
            }
            if (start>=end){
                //array[start]= tmp;
                break;
            }else{
                //此时end值小于tmp，交换
                array[start]=array[end];
            }


            //接着start向后走，找比tmp大的值
            while (start<end && array[start]<=tmp){
                start++;
            }
            //当start》end时，即有序
            if (start>=end){
                //array[start]= tmp;
                break;
            }else {
                //此时start值大于tmp，交换
                array[end]=array[start];
            }
        }
        array[start]= tmp;
        return start;
    }
    //快排核心
    private static void quick(int[] array, int low, int high) {
        //结束条件   （当=时即只有一个数据）
        if (low >= high) {
            return;
        }
        //1.优化    low high  直接插入排序
        if (high - low + 1 <= 3) {
            insertSort2(array, low, high);
            return;
        }
        //2.(2)三数取中
        medianOfThree(array,low,high);

        //找一次基准
        int par = partion(array, low, high);
        //左治
        quick(array, low, par - 1);
        //右治
        quick(array, par + 1, high);

    }
    public  static  void  medianOfThree(int[] array, int low, int high){
        int mid =(low+high)/2;
        //array[mid]<array[low]<array[high]
        if (array[low]>=array[high]){
            swap1(array,low,high);
        }
        if (array[low]<=array[mid]){
            swap1(array,low,mid);
        }
        if (array[mid]>=array[high]){
            swap1(array,mid,high);
        }

    }

    public static void quickSort(int[] array){

        quick(array,0,array.length-1);
    }

非递归快速排序

3.代码实现

 /**非递归快速排序
     *
     */
    public static void quickNorChild(int[]array, int low,int high){
        Stack<Integer>  stack = new Stack<>();

        int par =partion(array,low,high);

       if(par>low+1){
            stack.push(low);
            stack.push(par-1);
        }

        if (par<high-1){
            stack.push(par+1);
            stack.push(high);
        }

        while (!stack.isEmpty()){
            int end = stack.pop();
             int start = stack.pop();
            par= partion(array,start,end);

           if (par>start+1){
                stack.push(start);
                stack.push(par-1);
            }
           if(par<end-1){
                stack.push(par+1);
                stack.push(end);
            }
        }



    }

    public static  void quickNorSort(int []array){
        quickNorChild(array,0,array.length-1);
    }

六、冒泡排序

在无序区间，通过相邻数的比较，将最大的数冒泡到无序区间的最后，持续这个过程，直到数组整体有序

1.代码实现

代码如下（示例）：

 /**冒泡排序
     *时间复杂度：最好：o（n）    最坏：o（n^2）
     * 空间复杂度：o（1）
     *稳定性：稳定
     */

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


    public static void bubbleSort(int[] array) {
        for (int i = 0; i < array.length - 1; i++) {
            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;
            }
        }
    }

七、归并排序

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and
Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子
序列段间有序。若将两个有序表合并成一个有序表，称为二路归并

1.代码实现

代码如下（示例）：

/**归并排序
     * 时间复杂度：o（n*logn）
     * 空间复杂度：o(n)  即最后一次归并，创建的临时数组长度等于array的长度
     * 稳定性：稳定
     */
    public static void mergeSortChild(int []array,
                                      int low,int high){
        if (low>=high){
            return;
        }
        int mid = (low+high)/2;
        mergeSortChild(array,low,mid);
        mergeSortChild(array,mid+1,high);

        //开始合并
        merge(array,low,high,mid);

    }
    //合并函数
    public static void merge(int []array,
                             int low,int high,int mid){
        int s1=low;
        int s2=mid+1;
        int [] tmpArray =new int[high-low+1];
        int k = 0;  //数组的下标
        //俩个段都有数据
        while (s1<=mid && s2<=high){
            if (array[s1]<=array[s2]){
                tmpArray[k++]=array[s1++];
            }else{
                tmpArray[k++]=array[s2++];
            }
        }
        //第一个段还有若干数据
        while (s1<=mid){
            tmpArray[k++]=array[s1++];
        }
        //第2个段还有若干数据
        while (s2<=high){
            tmpArray[k++]=array[s2++];
        }

        //归并后的有序结果，将临时的数组的结果放入array中
        for (int i = 0; i <tmpArray.length ; i++) {
            array[low+i]=tmpArray[i];
        }

    }
    public  static void  mergeSort(int[] array){
        mergeSortChild(array,0,array.length-1);
    }

总结

提示：这里对文章进行总结：

Java---自定义排序的多种写法和其适用场景
Frank---7的博客
09-04 798
Comparable：适用于对象有“自然顺序”，并且这种顺序是对象的默认行为。Comparator：适用于需要多个排序规则，或不希望在对象类中嵌入排序逻辑的场景。Lambda &：适合简洁、临时的排序需求，尤其是Java 8及以上版本。
Java排序实战：如何高效实现电商产品排序
CalEx_Tech的博客
11-22 824
然而，随着电商平台的规模不断扩大，商品数量的急剧增加，如何对海量商品进行高效排序成为了电商系统开发的一大挑战。在电商系统中，排序的好坏直接影响到用户体验。通过合理的排序，我们可以使消费者更快速地找到他们想要的商品，从而提高用户的购物体验。同时，一个高效的排序算法还可以减轻服务器的负担，提高系统的稳定性。这种交互方式不仅可以提高用户的参与度，还可以帮助我们更好地理解用户的需求，从而改进我们的产品。3、分布式排序：对于大规模的数据，我们可以使用分布式排序算法，将数据分散到多个服务器上进行排序，以提高排序速度。
Java数据结构与算法-排序算法(概念、冒泡,选择,插入,希尔,快速,归并,基数排序)[day05]
SwaeLeeUknow的博客
09-16 580
排序算法 常见的排序算法分类： 排序的分类：(排序不是数据结构,排序是算法) 内部排序：指将需要处理的所有数据都加载 到内部存储器中进行排序。 外部排序：数据量过大，无法全部加载到内 存中，需要借助外部存储进行排序。 算法的时间复杂度与空间复杂度 时间复杂度 度量一个程序(算法)执行时间的两种方法 事后统计的方法：这种方法可行, 但是有两个问题：一是要想对设计的算法的运行性能进行评测，需要实际运行该程序；二是所得时间的统计量依赖于计算机的硬件、软件等环境因素, 这种方式，要在同一台计算机的相同状
python快速排序算法没看懂_快速排序算法（python）
weixin_42298727的博客
02-04 179
#!/usr/bin/python3# -*- coding: UTF-8 -*-'''''快速排序算法快速排序的基本思想是通过一趟排序将待排序列分割成独立的两个子序列，然后分别对这两个子序列分别快速排序，以达到整个序列有序。假设待排序序列为a[low:high+1]，从中任选一个元素值作为枢纽，再分别从左右两端向中间扫描，通过交换操作将不大于和不小于枢纽的元素分别置于左右两侧，使得一趟排序后左子...
算法学习笔记之快速排序（有图有讲解 小白也能看懂！ 看不懂你砍我）
qq_43227477的博客
03-10 607
快速排序是一种基于分治思想的排序算法，在代码之前我们先来画图理解这种算法 假设有一组无序数列：（灵魂画图 轻喷。。。） 算法总的思想是：在这组无序序列中，我们要选择一个合适的数字K（代码中选择的是第一个数） 来将这组数分成两部分 假设我们选择第一个数5 然后通过操作 把这组数分成 左边全为小于5的数 右边全为大于5的数 （如果有等于5的数也不影响 ） 就如图所示 分成了这两部分之后 这...
java快速排序，深入浅出，不懂的来看这里~
m0_49853352的博客
08-22 298
前段时间，我以前大学的一个学长去面试的时候，就问到了快速排序，并要求手写出来，那么，如果问到你，能不能在手纸上，呸！。。。在纸上写出来呢？ java的快速排序是面试经常要考到的哟！本文章接下来会深入浅出让大家能够了解快速排序，并能够知道快速排序的原理哦~ 1，什么是快速排序？ 让我们先来了解一下什么是快速排序，快速排序也叫快排，是冒泡排序的升级版，其效率要远高于冒泡排序，是一种高级的排序方式 它采用分而治之的思想，来完成排序 2，快速排序的思想 这里先了解一下即可，后面会有图解 采用分而治之的思想 1.
快速排序（图解）看完你还不懂？
逆风xmt的博客
01-14 301
package 排序算法; import java.util.Arrays; public class QuickSort { public static void main(String[] args) { int[] arr = new int[] {3,4,7,6,2,7,2,8}; quickSort(arr, 0, arr.length-1); System.out...
Java内存之happens-before和重排序
08-26
1. 程序次序规则：一个线程内，按照代码顺序，书写在前面的操作先行发生于书写在后面的操作。 2. 锁定规则：一个unLock操作先行发生于后面对同一个锁的lock操作。 3. volatile变量规则：对一个变量的写操作先行发生...
java代码-33 宋承友
07-16
从标题和描述来看，这可能是宋承友个人编写或分享的一系列Java代码示例，可能是为了教学、学习或者某个项目的实现。下面我们将深入探讨Java编程的核心概念以及可能涉及的知识点。 首先，让我们来看看`main.java`这...
Java基础入门--第二章--Java编程基础
最新发布
m0_73678713的博客
03-30 1347
变量：在程序运行期间，随时可能产生一些临时数据，应用程序会将这些数据保存在内存单元中，每个内存单元都用一个标识符标识，这些用于标识内存单元的标识符就称为变量，内存单元中存储的数据就是变量的值。数据类型分类。
快速排序法详解 不懂不要钱
Michael的专栏
03-18 912
快速排序法详解 不懂不要钱 快速排序的每一趟，都让关键数据排在了正确的位置
弱菜之快速排序实现，表示因为书上的看不懂只能自己写
H992109898的博客
01-04 762
自己的代码： void qsort(int a[], int left, int right) { if(left<right){ int pivot=a[left],l=left,r=right; while(l<r){ while(a[r]>=pivot&&l<r) r--; a[l]=a[r]; while(a[l]<=pivot&&l<r) l++;
实现类的顺序实例化（@DependOn）
Mrs_Yu的博客
11-23 1062
注解@DependsOn位于如下包 org.springframework.context.annotation 该注解用于声明当前bean依赖于另外一个bean。所依赖的bean会被容器确保在当前bean实例化之前被实例化。 举例来讲，如果容器通过@DependsOn注解方式定义了bean plant依赖于bean water,那么容器在会确保bean water的实例在实例化bean plant之前完成。 一般用在一个bean没有通过属性或者构造函数参数显式依赖另外一个bean，但实际上会使.
Java实现计数排序
热门推荐
南 墙
07-26 1万+
1 问题描述 给定一组数据，请使用计数排序，得到这组数据从小到大的排序序列。 2 解决方案 2.1比较计数排序 下面算法的时间复杂度为O(n^2)，空间复杂度为O(n)。此方法对于任意一组数据均可排序。 package com.liuzhen.practice; public class Main { public void comparisonCountingSort(int...
JAVA学习代码——数组排序
Reserved_person的博客
08-12 752
排序算法：Paixusuanfa.java package 数组_排序; //数组的几种排序算法的实现 public class Paixusuanfa { /*选择法排序: 假定有n个数的序列，要求按递增次序排序，算法步骤： （1）从n个数中选出最小数的下标，将最小数与第一个数交换位置； （2）除第一个数外，其余n-1个数再按方法（1）选出次小的数，与第二个数交换位置； （3
计数排序
08-09 123
原理 计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。 计数排序(Counting sort)是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。 空间换时间，所以适合...
C primer plus编程练习-第6章
XIANGYUNFEITIAN的博客
04-13 465
C primer plus编程练习-第6章 1.编写一个程序， 创建一个包含26个元素的数组， 并在其中储存26个小写字母。 然后打印数组的所有内容。 #include<stdio.h> int main(void) { char letter[26]; char ch = 'a'; int i; for (i = 0; ...
十大经典排序算法动画与解析，看我就够了！（配代码完全版）
weixin_33816821的博客
12-07 337
GitHub Repo：Sort Article Follow: MisterBooo · GitHub 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序。 内部排序是数据记录在内存中进行排序。 而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。 常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排...
汉字笔画排序算法与Java MySQL实现
由于这部分内容的描述较为简略，我们无法得知具体实现的细节，但可以推测这可能包含了上述Java和MySQL实现汉字笔画排序的旧代码文件。 #### 6. 实际应用 在实际应用中，汉字笔画排序可以应用于诸如姓名排序、字典...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值