JAVA实现常用排序

最新推荐文章于 2024-11-09 12:43:52 发布

lyc0115

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量123

点赞数

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

本文链接：https://blog.csdn.net/qq_37204393/article/details/105534392

版权

Java数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.冒泡排序

package com.lyc.BubbleSort;

/**
 * 冒泡排序，从小到大排序,时间复杂度为O(N^2)
 * 原理：比较相邻两个元素，如果前一个元素比后一个元素大，则交换这两个元素的值
 *       对每一对相邻元素做同样的工作，从开始第一对元素到结尾的最后一对元素。
 *       最终最后的位置就是最大值。
 * @author lyc
 * @create 2020-04-14 14:38
 */
public class BubbleSort {

    /*
        对数组a中元素进行排序
     */
    public static void sort(Comparable[] a){
        /*for(int i=0;i<a.length-1;i++){
            for(int j=0;j<a.length-1-i;j++){
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }
        }*/
        for (int i = a.length-1; i >0 ; i--) {
            for (int j=0;j<i;j++){
                if(greater(a[j],a[j+1])){
                    exch(a,j,j+1);
                }
            }

        }

    }

    /*
        比较v元素是否大于w元素
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换a数组中索引i和j处的值
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

2.选择排序

package com.lyc.selectionSort;

/**
 * 选择排序，时间复杂度O(N^2)
 * 原理：1.每一次遍历的过程中，都假定第一个索引处的元素是最小值，和其他索引处的值
 *      依次进行比较，如果当前索引处的值大于其他索引处的值，则假定其他索引处的
 *      值为最小值，最后可以找到最小值所在的索引。
 *      2.交换第一个索引处和最小值所在的索引处的值。
 * @author lyc
 * @create 2020-04-14 15:07
 */
public class SelectionSort {

    /*
     对数组a中元素进行排序
   */
    public static void sort(Comparable[] a){
        for(int i=0;i<a.length-1;i++){
            //假定本次遍历，最小值所在的索引是i
            int minIndex=i;
            for(int j=i+1;j<a.length;j++){
                if(greater(a[minIndex],a[j])){
                    //更换最小值所在索引
                    minIndex=j;
                }
            }
            //交换i和minIndex处的值
            exch(a,minIndex,i);
        }
    }

    /*
        比较v元素是否大于w元素
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换a数组中索引i和j处的值
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }

}

3.插入排序

package com.lyc.InsertionSort;

/**
 * 插入排序 ，时间复杂度O(N^2)
 * 原理：1.把所有的元素分为两组，已经排序的和未排序的；
 *      2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
 *      3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到
 *      找到一个元素小于等于待插入元素，那么就把待插入元素放到这个
 *      位置，其他元素向后移动一位。
 * @author lyc
 * @create 2020-04-14 15:51
 */
public class InsertionSort {

    public static void sort(Comparable[] a){
        /*
            对数组a中的元素进行排序
         */
        for (int i=1;i<a.length;i++){
            //当前元素为a[i],依次和前面的元素比较，找到一个小于等于a[i]的元素
            for(int j=i;j>0;j--){
                if (greater(a[j-1],a[j])){
                    //交换元素
                    exch(a,j-1,j);
                }else{
                    //找到该元素，结束
                    break;
                }
            }
        }
    }


    /*
        比较v元素是否大于w元素
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换a数组中索引i和j处的值
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

4.希尔排序

package com.lyc.InsertionSort;

/**
 * 插入排序 ，时间复杂度O(N^2)
 * 原理：1.把所有的元素分为两组，已经排序的和未排序的；
 *      2.找到未排序的组中的第一个元素，向已经排序的组中进行插入；
 *      3.倒叙遍历已经排序的元素，依次和待插入的元素进行比较，直到
 *      找到一个元素小于等于待插入元素，那么就把待插入元素放到这个
 *      位置，其他元素向后移动一位。
 * @author lyc
 * @create 2020-04-14 15:51
 */
public class InsertionSort {

    public static void sort(Comparable[] a){
        /*
            对数组a中的元素进行排序
         */
        for (int i=1;i<a.length;i++){
            //当前元素为a[i],依次和前面的元素比较，找到一个小于等于a[i]的元素
            for(int j=i;j>0;j--){
                if (greater(a[j-1],a[j])){
                    //交换元素
                    exch(a,j-1,j);
                }else{
                    //找到该元素，结束
                    break;
                }
            }
        }
    }


    /*
        比较v元素是否大于w元素
     */
    private static boolean greater(Comparable v,Comparable w){
        return v.compareTo(w)>0;
    }

    /*
        交换a数组中索引i和j处的值
     */
    private static void exch(Comparable[] a,int i,int j){
        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}