冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序java实现

最新推荐文章于 2023-02-20 10:05:20 发布

♞糖僧ᨐ

最新推荐文章于 2023-02-20 10:05:20 发布

阅读量133

点赞数

文章标签： java 排序算法算法数据结构

本文链接：https://blog.csdn.net/nojie1/article/details/125276053

版权

排序算法实现与总结

1冒泡排序原理

程序实现

public class Bubble {

    public  static  void sort(Comparable[]a){
        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);
                }
            }
        }

    }


    private   static  boolean greater(Comparable v,Comparable w){
        return  v.compareTo(w)>0;
    }


    private  static  void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

2选择排序

程序实现

/**
 * @author chao
 *
 * 选择排序
 * @create -06-2022-06-13-20:04
 */
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++) {
                if (greater(a[minindex],a[j])){
                    minindex=j;
                }
            }
            //交换元素
            exch(a,i,minindex);
        }
    }

    private   static  boolean greater(Comparable v,Comparable w){
        return  v.compareTo(w)>0;
    }


    private  static  void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }


}

3插入排序

程序实现

**
 * @author chao
 * @create -05-2022-05-19-20:40
 */
public class InsertSort {
    public  static void  exchange(int arr[],int i,int j){
        int temp;
        temp=arr[i];
        arr[i]=arr[j];
        arr[j]=temp;
    }



    public static boolean compared(Comparable i,Comparable j){
        return i.compareTo(j)>0;

    }

    public static void main(String[] args) {
        int []arr={1,3,2,5,6,9,8,7,4};

        for (int i = 1; i <arr.length ; i++) {

            for (int j = i; j >0 ; j--) {
                if(compared(arr[j-1],arr[j])){
                    exchange(arr,j-1,j);
                }else {
                    break;
                }
            }

        }


        for (int i = 0; i <arr.length ; i++) {
            System.out.println(arr[i]);
        }
    }
}

’

4希尔排序

程序实现

/**
 * @author chao
 * 希尔排序
 * @create -06-2022-06-13-20:32
 */
public class Shell {

    public  static  void sort(Comparable[]a){

        int h=1;
        while (h<a.length/2){
            h=2*h+1;
            
            
        }
        //2希尔排序
        while (h>=1) {
            for (int i = h; i < a.length; i++) {
                //2把待插入元素插入到有序数列中
                for (int j = i; j >= h; j -= h) {
                    //待插入的元素怒a[j] 和 a[j-h]

                    if (greater(a[j - h], a[j])) {
                        exch(a, j - h, j);
                    } else {
                        //
                        break;
                    }
                }
            }
            h = h / 2;

        }
    }




    private   static  boolean greater(Comparable v,Comparable w){
        return  v.compareTo(w)>0;
    }


    private  static  void exch(Comparable[] a,int i,int j){
        Comparable temp;
        temp=a[i];
        a[i]=a[j];
        a[j]=temp;
    }
}

5归并排序

代码实现

/**
 * @author chao
 * 归并排序
 * @create -06-2022-06-13-20:43
 */
public class Merge {
    private  static  Comparable[] assist;



    private  static  boolean less(Comparable v,Comparable w){

        return  v.compareTo(w)<0;
    }
    private  static  void exch(Comparable[]a,int i ,int j){

        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }

    public  static  void sort(Comparable[]a){

        //1初始化辅助数据assist
        assist=new Comparable[a.length];
        int  lo=0;
        int hi=a.length-1;
        //调用sort
        sort(a,lo,hi);



    }

    private  static  void sort(Comparable[]a,int lo,int hi){
        if(hi<=lo){
            return;
        }
        int mid=lo+(hi-lo)/2;

        //分别对每组数据进行排序
        sort(a, lo, mid);
        sort(a,mid+1,hi);
        merge(a,lo,mid,hi);


    }
    private  static  void merge(Comparable[]a,int lo,int mid ,int hi){

         //定义三个指针
        int i=lo;
        int  p1=lo;
        int p2=mid+1;

        //遍历
        while (p1<=mid&&p2<=hi){
            //比较对应索引值
            if(less(a[p1],a[p2])){
                assist[i++]=a[p1++];
            }else {
                assist[i++]=a[p2++];
            }

        }
        //遍历p1
        while (p1<=mid){
            assist[i++]=a[p1++];
        }
        //遍历p2
        while (p2<=hi){
            assist[i++]=a[p2++];


        }

        //把辅助数组中的元素拷贝到数组中
        for (int j = lo; j <=hi ; j++) {
            a[j]=assist[j];
        }


    }
}

6快速排序

代码实现


/**
 * @author chao
 * 快速排序
 * @create -05-2022-05-21-15:37
 */
public class Quick {


    public  static  void sort(Comparable[]a){
          int lo=0;
          int hi=a.length-1;
          sort(a,lo,hi);
    }
    private   static  void  sort(Comparable[]a,int lo,int hi){
          //安全性校验
        if(lo>=hi){
            return;
        }
        //需要对数组中lo元素到hi所引出的元素进行分组
        int partition = partition(a, lo, hi);//返回分界值所在索引
        sort(a,lo,partition-1);

        sort(a,partition+1,hi);
    }

    public  static  int  partition(Comparable[]a,int lo,int hi){

        Comparable key=a[lo];
        int left=lo;
        int right=hi+1;
        while(true){
            //先从右往左扫描

            while (less(key,a[--right])){
                 if(right==lo){
                     break;
                 }
            }
            while (less(a[++left],key)){
                if(left==hi){
                    break;
                }
            }

            if(left>=right) {
                break;
            }else {
                exch(a, left, right);
            }
        }

        exch(a,lo,right);
        return right;

    }

    private  static  boolean less(Comparable v,Comparable w){

         return  v.compareTo(w)<0;
    }
    private  static  void exch(Comparable[]a,int i ,int j){

        Comparable t=a[i];
        a[i]=a[j];
        a[j]=t;
    }
}

测试代码

import java.util.Arrays;

/**
 * @author chao
 * @create -06-2022-06-13-19:59
 */
public class BubbleTest {
    public static void main(String[] args) {
        Integer []arr={4,5,6,7,2,3,1,9};
       // Bubble.sort(arr); //冒泡排序

        //Selection.sort(arr); //选择排序
        
       // Shell.sort(arr);//希尔排序
        Merge.sort(arr);//归并排序
        //Quick.sort(arr);//快速排序
        System.out.println(Arrays.toString(arr));

      


    }
}

算法总结：

冒泡排序时间复杂度 O(N*2)

选择排序时间复杂度 O(N*2)

插入排序时间复杂度 O(N*2)

高级排序

希尔排序时间复杂度为O(n^1.5)

归并排序时间复杂度为O(n⋅log2n)

快速排序时间复杂度为O(n⋅log2n)