常見排序算法Java實現

僅僅給出代碼，也沒啥好說的

package com.demo.exercise;

public class MySort {

    public static void main(String[] args){
        int[] a = {5,1,12,3,125,50,66};
        for(int v : a){
            System.out.print(v + " ");
        }
        System.out.println();
        fastSort(a);
        for(int v : a){
            System.out.print(v + " ");
        }
        System.out.println();
    }
    
    //簡單選擇排序
    public static void selectSort(int[] a){
        int len = a.length;
        for(int i = 0; i < len; i++){
            int min = i;    //初始化min索引爲當前索引
            for(int j = i + 1; j < len; j++){    //與後面的比較
                if(a[j] < a[min]){    //如果後面下標對應的數值小於min下標對應的數值
                    min = j;        //後面下標值賦給min
                }
            }
            exchange(a, i, min);    //經過比較之後，交換當前的與最小的位置
            System.out.println((i+1) + "趟：");
            for(int v : a){
                System.out.print(v + " ");
            }
            System.out.println();
        }
    }
    
    //插入排序
    public static void insertSort(int[] a){
        int len = a.length;
        for(int i = 1; i < len; i++){
            for(int j = i; j > 0; j--){    //與前面的數比較
                if(a[j] < a[j - 1]){    //如果當前小於前面的
                    exchange(a, j, j - 1);//交換位置
                }
            }
            System.out.println((i) + "趟：");
            for(int v : a){
                System.out.print(v + " ");
            }
            System.out.println();
        }
        
    }
    
    //冒泡排序
    public static void bubbleSort(int[] a){
        int len = a.length;
        for(int i = 0; i < len - 1; i++){            //進行len-1次比較
            for(int j = 0; j < len - i - 1; j++){    //每一次中進行len-1-i次比較
                if(a[j] > a[j + 1]){
                    exchange(a, j, j + 1);
                }
            }
            System.out.println((i+1) + "趟：");
            for(int v : a){
                System.out.print(v + " ");
            }
            System.out.println();
        }
        
        //降序
//        int len = a.length;
//        for(int i = 0; i < len - 1; i++){            //進行len-1次比較
//            for(int j = 0; j < len - i - 1; j++){    //每一次中進行len-1-i次比較
//                if(a[j] > a[j + 1]){
//                    exchange(a, j, j + 1);
//                }
//            }
//        }
        
    }
    
    //希爾排序：數組越大，優勢越大(不是特別懂)
    public static void xierSort(int[] a){
        int len = a.length;
        int h = 1;
        while(h < len/3){
            h = 3*h + 1;
        }
        while(h >= 1){
            for(int i = h; i < len; i++){
                for(int j = i; j >= h; j -= h){
                    if(a[j] < a[j - h]){
                        exchange(a, j, j - h);
                    }
                }
            }
            h = h/3;
        }
    }
    
    //遞歸方法，歸併排序
    public static void mergeSort(int[] a, int low, int high){
        if(low < high){
            int mid = (low + high)/2;        //找到中間下標
            mergeSort(a, low, mid);            //對前半段再分割
            mergeSort(a, mid + 1, high);    //對後半段再分割
            merge(a, low, mid, high);        //排序&合併當前的兩段序列
        }
    }
    
    private static void merge(int[] array, int low, int mid, int high){
        int i, j, k, n1, n2;
        n1 = mid - low + 1;    //子序列1的大小
        n2 = high - mid;    //子序列2的大小
        int[] L = new int[n1];    //子序列1
        int[] R = new int[n2];    //子序列2
        
        //把數組前半段複製到子序列1:（k爲開始複製的下標）
        for(i = 0, k = low; i < n1; i++, k++){
            L[i] = array[k];
        }
        //把數組後半段複製到子序列2
        for(i = 0, k = mid + 1; i < n2; i++, k++){
            R[i] = array[k];
        }
        //分別掃描子序列1和子序列2，比較誰更小，誰就添加進數組
        for(k = low, i = 0, j = 0; i < n1 && j < n2; k++){
            if(L[i] < R[j]){    // < 升序 ; > 降序
                array[k] = L[i];
                i++;
            }else{
                array[k] = R[j];
                j++;
            }
        }
        //如果子序列1沒有掃描完，將其剩下的元素依次添加進數組
        if(i < n1){
            for(j = i; j < n1; j++,k++){
                array[k] = L[j];
            }
        }
        //子序列2也是如此
        if(j < n2){
            for(i = j; i < n2; i++,k++){
                array[k] = R[i];
            }
        }
    }
    
    //快速排序
    public static void fastSort(int[] a){
        int len = a.length;
        quickSort(a, 0, len - 1);
    }
    //實現
    private static void quickSort(int[] array, int low, int high){
        int i = low, j = high;
        int index;    //這個變量存儲基準數
        if(i >= j) return;
        index = array[i];
        while(i < j){    //直到i = j，循環結束
            // 從後向前找第一個小於index的數 
            while(i < j && array[j] >= index){    // 只要當前的數大於等於index就向前移動下標
                j--;    //向前移動
            }
            if(i < j){
                array[i++] = array[j];    //把找到的小於index的數賦值給i所在的位置，然後i向後移動一位
            }
            
            //前面代碼是把整個數組中小於index的數移動到數組前面
            //後面代碼是把整個數組中大於等於index的數移動到數組後面
            
            // 從前向後找第一個大於等於index的數 
            while(i < j && array[i] < index){    //只要當前的數小於index就向後移動下標
                i++;
            }
            if(i < j){
                array[j--] = array[i];    //把找到的大於等於index的數賦給j所在的位置，然後j向前移動一位
            }
        }
        array[i] = index;    //最後把index賦給i的位置，也可以寫爲j，因爲此時i = j
        quickSort(array, low, i - 1);    //分治思想：這個遞歸負責數組位置i前面部分的排序
        quickSort(array, i + 1, high);    //分治思想：這個遞歸負責數組位置i後面部分的排序
    }
    

    //交換
    private static void exchange(int[] a, int i, int j){
        int temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
    
}