java排序算法总结

Special case

已于 2022-08-01 22:49:06 修改

阅读量442

点赞数 1

分类专栏： java基础文章标签：数据结构 java 排序算法

于 2022-04-10 18:12:19 首次发布

本文链接：https://blog.csdn.net/weixin_48303059/article/details/124082685

版权

java基础专栏收录该内容

20 篇文章 2 订阅

订阅专栏

本文详细介绍了几种基本和高级排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序和快速排序。每种算法的时间复杂度和稳定性进行了分析，其中归并排序和快速排序以较高的效率脱颖而出，但快速排序在最坏情况下可能退化到O(n^2)。

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

排序算法

1.简单排序

1.1冒泡排序

在这里插入图片描述

package it.sort;

/**
 * @Author:Fwh
 * @date 2022/2/23 15:06
 */
public class Bubble {
    /*
    * 对数组中的数据进行排序
    * */
    public static void sort(Comparable[] a){
        for (int i = a.length; i > 0; i--) {
            for (int j = 0; j < i; j++) {
                if (greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }
    }

    /*
    *比较两个元素之间的大小
    * */
    public static boolean greater(Comparable a ,Comparable b){
        //a元素大于b元素就返回true
        return a.compareTo(b)>0;
    }
    /*
    * 数组元素 i j 交换位置
    * */
    public static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

1.2选择排序

在这里插入图片描述

package it.sort;

/**
 * @Author:Fwh
 * @date 2022/2/23 15:06
 */
//冒泡排序
public class Selection {
    /*
    * 对数组中的数据进行排序
    * */
    public static void sort(Comparable[] a){
        for (int i = 0; i < a.length - 2; i++) {
            //定义一个变量，记录最小元素的索引，默认为参与选择排序的第一个元素所在的位置
            int minIndex=i;
            for (int j = i+1; j < a.length; j++) {
                //需要比较最小索引minIndex的值和j处的值的大小
                if(greater(a[minIndex],a[j])){
                    minIndex=j;
                }
            }
            //交换索引i位置的值的最小所引出的位置的值
            exch(a,i,minIndex);
        }
    }

    /*
    *比较两个元素之间的大小
    * */
    public static boolean greater(Comparable a ,Comparable b){
        //a元素大于b元素就返回true
        return a.compareTo(b)>0;
    }
    /*
    * 数组元素 i j 交换位置
    * */
    public static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

1.3插入排序

在这里插入图片描述

package it.sort;

import org.omg.PortableServer.ForwardRequest;

/**
 * @Author:Fwh
 * @date 2022/2/23 15:06
 */
//插入排序
public class Insertion {
    /*
    * 对数组中的数据进行排序
    * */
    public static void sort(Comparable[] a){
        for (int i = 0; i < a.length; i++) {
            for (int j = i; j >0; j--) {
                //比较索引j与索引j-1处的值的大小。如果j小于j-1，则交换，否则，就满足要求
                if (greater(a[j-1],a[j])){
                    exch(a,j-1,j);
                }else {
                    break;
                }
            }
        }
    }

    /*
    *比较两个元素之间的大小
    * */
    public static boolean greater(Comparable a ,Comparable b){
        //a元素大于b元素就返回true
        return a.compareTo(b)>0;
    }
    /*
    * 数组元素 i j 交换位置
    * */
    public static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

2.高级排序

2.1希尔排序

在这里插入图片描述

package it.sort;

/**
 * @Author:Fwh
 * @date 2022/2/23 15:06
 */
//选择排序
public class Shell {
    /*
    * 对数组中的数据进行排序
    * */
    public static void sort(Comparable[] a){
        //根据a的长度，确定增长量长度的初始值
        int h = 1;
        while (h<a.length/2){
            h=2*h+1;
        }
        //希尔排序
        while(h>=1){
            //排序
            //首先找到待插入的元素:初始的h长度的数据默认是有序的
            for (int i = h; i < a.length; i++) {
                //然后插入到有序的序列中
                for (int j = i; j >=h; j-=h) {
                    //待插入的元素是a[j],比较a[j]与a[j-h]处
                    if (greater(a[j-h],a[j])){
                        //大于，交换元素
                        exch(a,j-h,j);
                    }else{
                        //待插入元素已经找到了合适的位置，结束循环
                        break;
                    }
                }
            }

            //减小h的值
            h=h/2;
        }
    }

    /*
    *比较两个元素之间的大小
    * */
    public static boolean greater(Comparable a ,Comparable b){
        //a元素大于b元素就返回true
        return a.compareTo(b)>0;
    }
    /*
    * 数组元素 i j 交换位置
    * */
    public static void exch(Comparable[] a,int i,int j){
        Comparable temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

2.2归并排序

在这里插入图片描述

package it.sort;

/**
 * @Author:Fwh
 * @date 2022/2/23 15:06
 */
//选择排序
public class Merge {
    public static Comparable[] assist;//完成归并操作需要的辅助数组

    /*
     * 对数组中的数据进行排序
     * */
    public static void sort(Comparable[] a) {
        //1.初始化辅助数组assist
        assist = new Comparable[a.length];
        //2.定义一个lo变量，和hi变量分别揭露最小索引和最大索引
        int lo = 0, hi = a.length - 1;
        //3.调用sort的重载方法，完成从lo到hi之间的元素的排序
        sort(a, lo, hi);
    }

    /*
     * 对数组中的从索引lo到hi之间的元素进行排序
     * */
    public static void sort(Comparable[] a, int lo, int hi) {
        if (lo >= hi) {
            return;
        }
        //对lo到hi之间的数据分成两个组
        int mid = lo + (hi - lo) / 2;
        //分别对两个组中的数据进行排序
        sort(a, lo, mid);
        sort(a, mid + 1, hi);
        //再把两个组中的数据进行归并
        merge(a, lo, mid, hi);
    }

    /*
     * 从索引lo到mid为一个子组，从mid+1到hi为另一个子组，把数组a中这两个子组合并成一个有序的大组
     * */
    public static void merge(Comparable[] a, int lo, int mid, int hi) {
        //定义三个指针
        int i = lo;
        int p1 = lo;
        int p2 = mid + 1;
        //移动p1，p2指针，比较相应索引处的值找出小的，放到辅助数组
        while (p1<=mid&&p2<=hi){
            //比较对应所引处的值
            if(less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else assist[i++]=a[p2++];
        }
        //只要一个子数组遍历完毕，另一个顺序移动添加到辅助数组中
        //p1指针没有走完，顺序移动p1指针，将数据添加到辅助数组
        while(p1<=mid){
            assist[i++]=a[p1++];
        }
        //p2指针没有走完，顺序移动p1指针，将数据添加到辅助数组
        while (p2<=hi){
            assist[i++]=a[p2++];
        }
        //把辅助数组copy到原始数组中
        for (int j = lo; j <= hi; j++) {
            a[j]=assist[j];
        }
    }

    /*
     *比较两个元素之间的大小
     * */
    public static boolean less(Comparable a, Comparable b) {
        //a元素大于b元素就返回true
        return a.compareTo(b) < 0;
    }

    /*
     * 数组元素 i j 交换位置
     * */
    public static void exch(Comparable[] a, int i, int j) {
        Comparable temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}

2.3快速排序

在这里插入图片描述

2.算法性能分析

2.1冒泡排序

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

稳定性：稳定的算法

2.2选择排序

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

稳定性：不稳定的算法

2.3插入排序

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

稳定性：稳定的算法

2.4希尔排序

时间复杂度由于增长量的不同，不能常规的计算出时间复杂度

采用事后估算法，逆序一组数据，分别使用插入排序和希尔排序运行，得到的结果就是希尔排序的效率大大强于插入排序

稳定性：不稳定的算法

2.5归并排序

时间复杂度:O(nlogn)

归并排序的缺点：需要申请额外的数组空间。导致空间复杂度提升，是典型的以空间换时间的操作

稳定性：稳定的算法

2.6快速排序

时间复杂度:**O(nlogn)最坏的情况下是O(n^2) **

稳定性：不稳定的算法

2.7快速排序和归并排序的区别

快速排序是另外一种分治的排序算法,它将一个数组分成两个子数组,将两部分独立的排序。
快速排序和归并排序是互补的:归并排序将数组分成两个子数组分别排序,并将有序的子数组归并从而将整个数组排序,而快速排序的方式则是当两个数组都有序时,整个数组自然就有序了。在归并排序中,一个数组被等分为两半,归并调用发生在处理整个数组之前,在快速排序中,切分数组的位置取决于数组的内容,递归调用发生在处理整个数组之后。