Java八大内部排序算法

最新推荐文章于 2022-10-19 23:40:40 发布
最新推荐文章于 2022-10-19 23:40:40 发布
阅读量638 收藏 1
点赞数
分类专栏： Java 文章标签： 算法 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43663493/article/details/119933391
版权

排序算法的分类

在这里插入图片描述

时间复杂度以及空间复杂度

在这里插入图片描述

注：为了进行一定的比较，此处不按照上面的顺序。

直接插入排序

基本思想

在要排序的一组数中，假定前n-1个数已经排好序，现在将第n个数插到前面的有序数列中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。

场景：

在这里插入图片描述

正如当我们打牌的时候，需要对扑克牌排序。抽到牌后(假设每次只抽一张)，依次从排好序的排中与手中的牌进行比较，插入到合适的位置。

在这里插入图片描述

/**
 * 插入排序
 * @param a
 */
public static void sort(int[] a){
    int N = a.length;
    //i需要取到N-1，并且这里的i是从1开始的，可以这么认为第一个就是一个初始的有序的数组
    for (int i=1;i<N;i++){
        for (int j=i;j>0;j--){
            if ((a[j-1]<a[j])){
                continue;
            }
            int tem = a[j-1];
            a[j-1] = a[j];
            a[j] = tem;
        }
    }
}


    /**
     * 插入排序
     * @param a 排序数组
     */
    public static void sort(Comparable[] a){
        //将a[] 按升序排序
        int N = a.length;
        for (int i=1; i<N;i++){//i需要取到N-1
            //将a[i]插入到a[i-1],a[i-2],a[i-3]...之中
            for (int j = i; j>0&& Example.more(a[j-1],a[j]); j--){//Example.less(a[j-1],a[j])
                Example.exch(a,j,j-1);
            }
        }
    }

时间复杂度与空间复杂度

因为是内部排序所以空间复杂度可以直接不考虑就是0(1)，我们来看时间复杂度：主要体现在比较所花的时间上，最坏的情况下就是：0+1+ 2 + 3 +…+(n-1)=(n-1)*n/2=0(n2)。

最坏情况：数组已经排序好，但是从大到小的排序，此时每次的比较后都需要交换

最好情况：这个当然就是已经排序好了（从小到大）

选择排序

基本思想：

在长度为N的无序数组中，

第一次遍历n-1个数，找到最小的数值与第一个元素交换；
第二次遍历n-2个数，找到最小的数值与第二个元素交换；
。。。
第n-1次遍历，找到最小的数值与第n-1个元素交换，排序完成

场景：上一个场景中是抽到一张牌后插入到手中已经排好序的手牌之中。而选择排序有点不同，它是从没有排序的牌中选取到最小的放入已排序的末尾。

在这里插入图片描述

/**
 * 选择排序
 * @param a 需要排序的数组
 */
public static void sort(int[] a){
    int N = a.length;
    //这里是从0开始的，因为后续的操作如果需要的话会对下标为0的位置进行赋值操作
    for (int i=0;i<N-1;i++){
        int min = i;
        for (int j=i+1;j<N;j++){
            if (a[i]<a[j]){
                min = j;
                continue;
            }
            int tem = a[i]; //将交换放到if外面
            a[i] = a[j];
            a[j] = tem;
        }
    }
}

    public static  void sort(Comparable[] a){
        //将a[]按升序排序
        int N = a.length;
        for (int i=0;i<N-1;i++){ //书中这里是for (int i=0;i<N;i++) 考虑边界这里只需要执行到a.length-2就可以了
            //将a[i]和a[i+1..N]中最小的元素交换
            int min = i;
            for (int j=i+1;j<N;j++){
                if (Example.more(a[min],a[j])) {//书中这里为：Example.less(a[j],a[min])
                    min = j;
                }
            }
            Example.exch(a,i,min);
        }
    }

空间复杂度：0(1)，内部排序

时间复杂度：0(n2)主要体现在

最坏情况：以排好序（从大到小）

最好情况：以排序好（从小到大）

直接插入排序与选择排序的可视比较：

在这里插入图片描述

希尔排序

也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

排序思想：在要排序的一组数中，根据某一增量分为若干子序列，并对子序列分别进行插入排序。
然后逐渐将增量减小,并重复上述过程。直至增量为1,此时数据序列基本有序,最后进行插入排序。

在这里插入图片描述

    public static void sort(int a[]){
        int N = a.length;
        int h = 1;
        while (h<N/3){
            //获取递增序列
            h=3*h+1;//1,4,13,40,121,....
        }
        while (h>=1){
//            将数组变为任意间隔h的元素都是有序的（h有序数组）
            for (int i = h;i<N;i++){
                //将a[i] 插入到a[i-h],a[i-2*h],a[i-3*h]...之中
                for (int j=i;j >= h;j-=h){
                    if (a[j]<a[j-h]){
                        int tem = a[j-h];
                        a[j-h] = a[j];
                        a[j]=tem;
                    }
                }
            }
            h = h/3;
        }

    }

    public static void sort(Comparable[] a){
        int N = a.length;
        int h = 1;
        while (h<N/3){
            //获取递增序列
            h=3*h+1;//1,4,13,40,121,....
        }
        while (h>=1) {
//            将数组变为任意间隔h的元素都是有序的（h有序数组）
            for (int i = h; i < N; i++) {
                //将a[i] 插入到a[i-h],a[i-2*h],a[i-3*h]...之中
                for (int j=i;j >= h&& Example.more(a[j-h],a[j]);j-=h){
                    Example.exch(a,j-h,j);
                }
            }
            h=h/3;
        }
    }

空间复杂度：0(1)，内部排序

时间复杂度： O(n^(1.3—2))

最坏情况：

最好情况：

归并排序

归并：将两个有序的数组归并成一个更大的有序数组。根据这个操作就得到了递归排序算法：归并排序。

原理：要将一个数组排序，可以先（递归的）将它分成两半分别排序，然后归并起来。

归并最吸引人的性质就是它能够保证任意长度为N的数组排序所需要时间和NlogN成正比：主要缺点则是它所需要的额外空间和N成正比。

在这里插入图片描述

代码：

public class MergeSort {
    
    public  static void mergerSort(int[] array){
        mergerSort(array,0,array.length-1);
    }
    /**
     * 实现归并排序的具体思路
     * 递归每个数组并排序的过程
     * @param array
     * @param low
     * @param hight
     */
    private static void mergerSort(int[] array, int low, int hight) {
        int mid = low +(hight - low) /2;
        if (low<hight) {
            //处理左边
            mergerSort(array, low, mid);
//            处理右边
            mergerSort(array, mid + 1, hight);
//            归并
            merger(array, mid, low, hight);
        }
    }

    /**
     * 将两个有序数组进行归并
     * @param array 待排序的数组
     * @param middle  中间的位置
     * @param low  起始的位置
     * @param hight 结束的位置
     */
    private static void merger(int[] array, int middle, int low, int hight) {
        int j = middle+1;
        int[] temp = new int[array.length];
        int tIndex = low,cIndex = low;

        // 核心代码，完成比较
        while (low <= middle && j <= hight) {
            if(array[low] < array[j]){
                temp[tIndex++] = array[low++];
            }else{
                temp[tIndex++] = array[j++];
            }
        }

        // 将未归并完的数组来进行添加
        while(low <= middle){
            temp[tIndex++] = array[low++];
        }

        while (j <= hight){
            temp[tIndex++] = array[j++];
        }

        // 将排序好数组赋值给原数组
        while (cIndex <= hight) {
            array[cIndex]  = temp[cIndex];
            cIndex++;
        }
    }

    public static void main(String[] args) {
        int b[] = {1,4,2,8,5,3,0,12,3,2,7,3};
        mergerSort(b);
        for (int s:b){
            System.out.print(" "+s);
        } 
    } 
}

快速排序

快速排序是一种分治的排序算法。它将一个数组分为两个数组，两部分独立的排序。快速排序与归并排序是互补的：归并排序将数组分为两个子数组分别排序，并将有序的子数组归并以将整个数组排序；而快速排序将数组排序的方式则是当两个数组都有序时整个数组也就自然有序了。在第一种情况中，递归调用发生在处理整个数组之前；在第二种情况中，递归调用发生在处理整个数组之后。在归并排序中，一个数组被分为两半；在快速排序中，切分的位置取决于数组的内容。

该方法的基本思想：

  • 1．先从数列中取出一个数作为基准数。
  • 2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
  • 3．再对左右区间重复第二步，直到各区间只有一个数。
public class QuickSort {

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

    public static void quickSort(int[] arr,int start,int end){
        if(start<end){
            //把数组中的第0个数字作为标准数
            int stard = arr[start];
            //记录需要排序的下标
            int low = start;
            int high = end;
            //循环找比标准数大的数和比标准数小的数
            while(low<high){
                //右边的数字比标准数大
                while(low<high && stard<=arr[high]){
                    high--;
                }
                //使用右边的数字替换左边的数
                arr[low] = arr[high];
                //如果左边的数字比标准数小
                while(low<high && arr[low]<=stard){
                    low++;
                }
                arr[high] = arr[low];
            }
            //把标准数赋给low所在位置的元素(low或high都可以，因为它们两个都重复了)
            arr[low] = stard;
            //处理所有的小于标准数的左边的数字
            quickSort(arr, start, low);
            //处理所有的大于标准数的右边的数字
            quickSort(arr, low+1, end);

        }
    }
    public static void main(String[] args) {
        int[] arr = new int[]{3,4,6,7,2,7,2,8,0,9,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

堆排序

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种**选择排序，**它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。

在这里插入图片描述

这种逻辑结构映射到数组中就是下面这个样子

在这里插入图片描述

public class HeapSort {
    public static void main(String []args){
        int []arr = {9,8,7,6,5,4,3,2,1};
        sort(arr);
        System.out.println(Arrays.toString(arr));
    }
    public static void sort(int []arr){
        //1.构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--){
            //从第一个非叶子结点从下至上，从右至左调整结构
            adjustHeap(arr,i,arr.length);
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int j=arr.length-1;j>0;j--){
            swap(arr,0,j);//将堆顶元素与末尾元素进行交换
            adjustHeap(arr,0,j);//重新对堆进行调整
        }

    }

    /**
     * 调整大顶堆（仅是调整过程，建立在大顶堆已构建的基础上）
     */
    public static void adjustHeap(int []arr,int i,int length){
        int temp = arr[i];//先取出当前元素i
        for(int k=i*2+1;k<length;k=k*2+1){//从i结点的左子结点开始，也就是2i+1处开始
            if(k+1<length && arr[k]<arr[k+1]){//如果左子结点小于右子结点，k指向右子结点
                k++;
            }
            if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[i] = arr[k];
                i = k;
            }else{
                break;
            }
        }
        arr[i] = temp;//将temp值放到最终的位置
    }

    /**
     * 交换元素
     */
    public static void swap(int []arr,int a ,int b){
        int temp=arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }
}

冒泡排序

冒泡排序，当然冒泡就和和生活中的冒泡有一定关系的。烧开水时会有许多的气泡向水面冒出来，也就是密度小的向上移动。

基本思想：每一次把最大的数放到数组的末尾，直至数组排序完成。

//	冒泡排序
public static void BubbleSort(int[] arr) {
	for (int i = 1; i < arr.length ; i++) {//排序需要的趟数。
		
		for (int j = 0; j < arr.length - i ; j++) {//
			
			if(arr[j + 1] < arr[j]) {
				
				int tem = arr[j + 1];
				
				arr[j + 1] = arr[j];
				
				arr[j] = tem;
				
			}
			
		}
		
	}
	
}

基数排序

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

算法步骤：

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

动态效果示意图：

在这里插入图片描述

/**
 * 基数排序
 */
public class RadixSort {
    public static void main(String[] args) {
        int a[] = {1,4,2,8,5,3,0,12,100,3,2,7,3};
        sort(a,100);
        for (Integer i:a){
            System.out.print(" "+i);
        }
        System.out.println();
    }

    /**
     * 基数排序
     * @param array 待排序数组
     * @param d 最高位数
     */
    public static void sort(int[] array,int d)
    {
        int n=1;//代表位数对应的数：1,10,100...
        int k=0;//保存每一位排序后的结果用于下一位的排序输入
        int length=array.length;
        int [][]bucket=new int[10][length];//排序桶用于保存每次排序后的结果，这一位上排序结果相同的数字放在同一个桶里
        int []order=new int[length];//用于保存每个桶里有多少个数字
        while(n<=d)
        {
            for(int num:array) //将数组array里的每个数字放在相应的桶里
            {
                int digit=(num/n)%10;//计算单位 0-9
                bucket[digit][order[digit]]=num;
                order[digit]++;
            }
            for(int i=0;i<length;i++)//将前一个循环生成的桶里的数据覆盖到原数组中用于保存这一位的排序结果
            {
                if(order[i]!=0)//这个桶里有数据，从上到下遍历这个桶并将数据保存到原数组中
                {
                    for(int j=0;j<order[i];j++)
                    {
                        array[k]=bucket[i][j];
                        k++;
                    }
                }
                order[i]=0;//将桶里计数器置0，用于下一次位排序
            }
            n*=10;
            k=0;//将k置0，用于下一轮保存位排序结果

        }
    }
}

参考：

https://www.jianshu.com/p/8340dfaea3af

图解排序算法(三)之堆排序

算法（第四版）

工具类：

package utils;

/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/7/21 21:18
 */
public class Example {
    /**
     * 对传进来的两个参数进行比肩 第一个参数更大返回1，更小返回-1，相等返回0
     * @param v 需比较的参数
     * @param w 需比较的参数
     * @return v比w大返回1，小返回-1，相等返回0
     */
    public static boolean more(Comparable v, Comparable w) {
        //compareTo：v比w大返回1，小返回-1，相等返回0
        return v.compareTo(w) > 0;//算法（第四版）这里是v.compareTo(w) < 0，我觉得这里用>更合适并且把方法签名改为了more
    }

    /**
     * 数组内两数交换
     * @param a 数组
     * @param i 数组下标
     * @param j 数组下标
     */
    public static void exch(Comparable[] a, int i, int j) {
        Comparable t = a[i];
        a[i] = a[j];
        a[j] = t;
    }

    public static void show(Comparable[] a) {
        for(int i = 0; i<a.length; i++) {
            System.out.print(a[i] + " ");
        }
    }

    public static boolean isSorted(Comparable[] a) {
        for(int i = 1; i < a.length; i++) {
            if(less(a[i],a [i-1])) return false;
        }
        return false;
    }

}

import java.util.Arrays;

/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/7/22 8:58
 */
public class ui {

    /**
     * 打印整个数组
     * @param a 数组
     */
    public static void print(int []a) {
        for(int i = 0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    /**
     * 打印数组排序中的某趟顺序
     * @param a 数组
     * @param k 趟数
     */
    public static void process(int []a,int k) {
        System.out.println("第"+k+"躺:"+ Arrays.toString(a));
    }

}

 return false;
}

}


```java
import java.util.Arrays;

/**
 * TODO 类描述
 *
 * @author qijian.
 * @date 2021/7/22 8:58
 */
public class ui {

    /**
     * 打印整个数组
     * @param a 数组
     */
    public static void print(int []a) {
        for(int i = 0;i<a.length;i++) {
            System.out.print(a[i]+" ");
        }
        System.out.println();
    }

    /**
     * 打印数组排序中的某趟顺序
     * @param a 数组
     * @param k 趟数
     */
    public static void process(int []a,int k) {
        System.out.println("第"+k+"躺:"+ Arrays.toString(a));
    }

}
柒间
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA内置排序方法
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
12-21 2171
排序是按特定顺序组织数据项集合的过程，通常是升序或降序。有许多不同的算法可用于对数据进行排序，包括冒泡排序、选择排序、插入排序、归并排序和快速排序等。 Java 是一种编程语言，它提供了许多用于对数据进行排序的内置方法，包括Arrays.sort() 和 Collections.sort() 这些方法使用高效的排序算法来快速高效地对数据进行排序。
java 内置排序_八大常见内排序java实现
weixin_39913472的博客
02-24 282
虽然排序算法烂大街了，但是哥依然用java实现了一遍，只为自己练练手，后面可以时不时的回头看看。。。仅此而已，各位可以提意见，莫喷！！一、冒泡排序基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换1 /**2 * 冒泡排序3 *@paramda...
Java常用内排序算法
学而不思则罔，思而不学则殆。
09-05 291
目录 1、冒泡排序（Bubble Sort） 2、快速排序（Quick Sort） 3、选择排序（Selection Sort） 4、堆排序（Heap Sort） 5、插入排序（Insertion Sort） 6、希尔排序（Shell Sort） 7、归并排序（Merge Sort） 其他排序 8、计数排序（Counting Sort） 9、桶排序（Bucket Sort） ...
用Java实现常见的8种内部排序算法
hello_1566的博客
05-01 582
一、插入类排序 插入类排序就是在一个有序的序列中，插入一个新的关键字。从而达到新的有序序列。插入排序一般有直接插入排序、折半插入排序和希尔排序。 1. 插入排序 1.1 直接插入排序 /** * 直接比较，将大元素向后移来移动数组 */ public static void InsertSort(int[] A) { for(int i = 1; i < A.length; i++) { int temp = A[i]; //temp 用于存储元素，防止后面移动
Java 提供的默认排序算法
矩阵Matrix
10-19 564
Java 提供的默认排序算法
八大排序-java实现版
03-01
八大排序java实现版本，直接插入排序、折半插入排序、冒泡排序、简单选择排序、希尔插入排序、快速排序 、堆排序、2-路归并排序 、基数排序，并有时间比较，博文...
Java实现八大排序算法
09-18
Java实现八大排序算法
Java 八大排序
04-22
选择排序算法准则： 每种排序算法都各有优缺点。因此，在实用时需根据不同情况适当选用，甚至可以将多种方法结合起来使用。 选择排序算法的依据 影响排序的因素有很多，平均时间复杂度低的算法并不一定就是最优的...
java实现的八大排序算法 用例 有备注解释
04-11
java实现的八大排序算法 用例 有备注解释 纯个人实现
常见的八大排序算法及其JAVA实现
04-26
http://blog.csdn.net/holmofy/article/details/70245895 文章的实现代码
java常见八种排序算法
06-29
java最常见的八种排序算法
java 内置排序_JAVA内置排序Arrays.sort实现简述
weixin_39638305的博客
02-16 418
前言在JAVA开发中，我们经常需要操作数组和集合，其中数组和链表的排序是重中之重。Arrays.sort方法用来对数组排序。Collections.sort()方法用来对链表排序，而Collections.sort()的底层，其实使用的也是Arrays.sort方法。所以JAVA内置排序的核心类，都在于Arrays工具类，接下来我们也重点剖析该类。1. Arrays工具类我们先来看下Arrays工...
java自带的排序方法sort
index_jsf的专栏
11-13 9777
/* * To change this template, choose Tools | Templates * and open the template in the editor. */ package com.city.test; import java.util.Arrays; import java.util.Comparator; /** * *
Java Arrays类进行数组排序
weixin_34406086的博客
07-03 482
　　排序算法，基本的高级语言都有一些提供。C语言有qsort()函数，C++有sort()函数，java语言有Arrays类(不是Array)。用这些排序时，都可以写自己的排序规则。 　　Java API对Arrays类的说明是：此类包含用来操作数组（比如排序和搜索）的各种方法。 1.对基本数据类型的数组的排序 　　　说明：(1)Arrays类中的sort()使用的是“经过调优的快速排序法”...
java自带的排序工具
Jalen备忘录
12-11 7140
import java.util.Arrays; import java.util.Collections; import java.util.List; /** * * TT * * Description: * * @author Mcchu * @date 2017/12/8 10:43 */ public class TT { /** * 正序
Java自带排序方法
wudiyong22的专栏
08-08 7256
Collections.sort(List list) 该方法是升序排序，方法的内部采用了快排实现，但该方法是稳定的。 除Integer、Float、Double、String等Java自带类型外，list里的所有元素必须实现Comparable接口的compareTo方法。 例子： class Bean implements Comparable{       public
Java自带的排序
u012147447的博客
06-20 2277
Java中自带了两种排序方法， 一种是 Collections.sort()， 另一种是 Arrays.sort() 参考博文： https://blog.csdn.net/u011410529/article/details/56668545 由上面的文章我们可以看出 自带的两种排序方法在 jdk1.7之前都用的是归并排序， 现在都用的是 TimSort, TimSort 算法的实现原理是：找...
java 排序方式_Java中几种常见的排序方式
weixin_28737603的博客
02-16 120
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。代码/***冒泡法排序*比较相邻的元素。如果第一个比第二个大，就交换他们两个。*对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。...
Java中自定义排序的几种方式
heyong的博客
08-20 9982
一、普通类型数组int[] 对于普通数据类型数组，Java的Arrays类中提供了几种方法： Arrays.sort(int[] a)：按照数字顺序排列指定的数组 sort(int[] a, int fromIndex, int toIndex)：按升序排列数组的指定范围 Arrays.parallelSort(int[] a) ：按照数字顺序排列指定的数组 Arrays.parallelSort(int[] a, int fromIndex, int toIndex) ：按照数字顺序排列数组的指定范围
java八大排序算法
最新发布
10-17
Java八大排序算法包括：冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序和计数排序。 1. 冒泡排序：比较相邻的元素，如果前一个比后一个大，就交换它们的位置，一次遍历后最大的元素就会被排...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值