排序算法(Java)

一：冒泡排序

public class Bubsort {

    public static void main(String[] args) {
        int[] array = new int[]{1,45,3,4,6,8,13,65,9,16};
        int[] sortarray = bubSort(array);
        System.out.println(Arrays.toString(array));
    }

    private static int[] bubSort(int[] array) {
        int length=array.length;

        for(int i=0; i<length-1; i++) {
            /*优化*/
            boolean flag=true;
            for (int j = 0; j < length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    flag = false;
                    /*  if(array[j]>array[j+1]):从小到大排序 */
                    /*  if(array[j]<array[j+1]):从大到小排序 */
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp; }
            }
            /*一趟排序下来，发现没有一次比较*/
            if (flag) break;
        }
                return  array;
    }


}

二：选择排序

public class Chooessort {
    public static void main(String[] args) {

        int[] array = new int[]{1,32,6,8,9,14,7};
        int[] sortArray =fastsort(array);
        System.out.println(Arrays.toString(array));

    }

    private static int[] fastsort(int[] array) {
        int length=array.length;
        for(int i=0; i<length-1; i++){
            /*选择排序*/
            int min=array[i];
            int minIndex = i;
            for(int j=i+1; j<length; j++){
                if(min>array[j]){
                    min =array[j];
                    minIndex=j;
                }
            }
            /*有改变做一个交换*/
            if(minIndex != i){
                array[minIndex] =array[i];
                array[i] = min;
            }
        }
        return  array;
    }
}

三：快速排序

public class Fastsort {
    public static void main(String[] args) {

        int[] array = new int[]{1,25,3,6,12,16,7,10};
        int left=0;
        int right = array.length-1;
        fastsort(array,left,right);
        System.out.println(Arrays.toString(array));

    }

    private static void fastsort(int[] array,int left,int right) {
        /*快速排序：这里用到双指针的方式，主要，右指针优先开始*/
        /*递归出口*/
        if(left>=right){ return; }
        int l=left, r =right;
        while(l<r){
            /*一个注意点：右指针先找，否则失败，顺序不能交换！！！！*/
            while(l<r&&array[r]>=array[left]) r--;
            while(l<r&&array[l]<=array[left])l++;
            if(r==l){
                int temp = array[l];
                array[l] =array[left];
                array[left] =temp;
            }else{
                int temp = array[l];
                array[l] = array[r];
                array[r] =temp; } }
            /*左递归*/
            fastsort(array,left,r-1);
            /*右递归*/
            fastsort(array,l+1,right); }
}

四：插入排序

public class Insertsort {
    public static void main(String[] args) {

        int[] array = new int[]{12,3,6,9,7,4,5};
        int[] sortArray = insertsort(array);
        System.out.println(Arrays.toString(sortArray));
    }

    private static int[] insertsort(int[] array) {
        int length=array.length;
        for(int i=1; i<length; i++){  /*总共插入的次数*/
            /*插入排序的:从后往前插,每次插入排序比较时，前面都是已经排序好的*/
            int x=array[i];
            int pos = i-1;
            /*插入的下标至少大于0，对吧，
            另外，&&后面的条件是选择从小到啊排序还是从大到小排序*/
            while(pos>=0&&array[pos]>x){
                array[pos+1] =array[pos];
                pos--;
            }
            /*找到这个小的，在它之后插入*/
            array[pos+1]=x;
        }
        return  array;
    }
}

五：希尔排序

public class Xiersort {
    public static void main(String[] args) {

        int[] array = new int[]{12,3,6,9,7,4,5};
        int[] sortArray = xiersort(array);
        System.out.println(Arrays.toString(sortArray));
    }

    private static int[] xiersort(int[] array) {
        /*希尔排序不同插入排序的是间隔的问题：
        * 插入排序的时间间隔是1*/
        for(int interval = array.length/2; interval>0; interval/=2){
            for(int i=interval;i<array.length; i+=interval){
                int x = array[i];
                int pos=i-interval;
                while(pos>=0&&array[pos]>x){
                    array[pos+interval] = array[pos];
                    pos -=interval;
                }
                array[pos+interval]=x;
            }
        }
        return  array;

    }
}