Java數組的排序演算法

　　在Java中，實現數組的排序演算法有很多，如冒泡排序法、選擇排序法、直接插入法和快速排序法等。下麵介紹幾種排序演算法的具體 實現。

　　本文引用文獻：Java必須知道的300個問題。

1.冒泡排序法

　　1.1 基本思想：

　　　　比較待排序的數據元素中的相鄰元素：如果前面的元素大於後面的元素，那麼將兩個元素交換位置；否則不變。即：永遠保持大的元素值在待排序元素中的最後面位置。這樣，數組元素就像氣泡一樣從底部上升到頂部。

　　1.2 過程實例：

　　　　每一輪，排序數組的長度減1次（每一輪結束後，最大元素都是最後一個元素。因此下輪比較過程中最後一次比較不用進行。）

　　1.3 代碼實現

public static void main(String[] args) {
    //初始化數組
    int[] array = {63,4,24,1,3,13};
    //排序
    for (int i = 1; i < array.length; i++) {
        for (int j = 0; j < array.length - i; j++) {
            if(array[j] > array[j+1]){
                int temp = array[j];
                array[j] = array[j+1];
                array[j+1] = temp;  
            }
        }
    }
    //輸出結果
    System.out.println(Arrays.toString(array));
}

2. 選擇排序法

　　2.1 基本思想

　　　　每一輪從待排序的數據元素中選出最小（最大）的一個元素，將該元素與待排序的數據元素的最前面（最後面）的元素進行交換，直到全部待排序的數據元素排完。　　

　　2.2 過程實例　　

  　2.3 代碼實現

//初始化數組
int[] array = {63,4,24,1,3,13};

//排序
int len = array.length;
//控制輪數
for (int i = 1; i < len; i++) {
    int max = array[0];
    int index = 0;
    //查找最大值
    for (int j = 1; j < len - (i - 1); j++) {
        if(max < array[j]){
            max = array[j]; 
            index = j;
        }
    }
    //互換位置
    int temp = array[index];
    array[index] = array[len - i];
    array[len - i] = temp;
}

//輸出
System.out.println(Arrays.toString(array));

3. 直接插入排序法

　　3.1 基本思想

　　　　1. 將n個有序元素放在數組中 --> 2.確認要插入元素的位置 --> 3.將數組中的要插入元素的位置後面的元素向後移一個位置  --> 4.將要出如的元素插到合適的位置上 --> 5.重覆2. 3. 4.直到所有元素均插入到數組中。

　　3.2 實例過程

　　3.3 代碼實現

//初始化數組
int[] array = {20,40,90,30,80,70,50};

//排序
int j;
for (int i = 1; i < array.length; i++) {
    int temp = array[i];
    for (j = i - 1; j > 0 && array[j] > temp; j--) {
        array[j+1] = array[j];
    }
    array[j+1] = temp;
}

//輸出
System.out.println(Arrays.toString(array));

4. 快速排序法

 　　4.1 基本思想

　　　　通過一趟排序將要排序的數據分割成獨立的兩部分（通常選取中數作為分割線），其中一部分的所有數據都比另一部分的所有數據要小，然後再按此方法對這兩部分數據進行快速排序，整個過程可以通過遞歸進行。

　　4.2 實例過程

　　4.3 代碼實現

public static void main(String[] args) {
    //初始化數組
    int[] array = {49,38,65,97,76,13,27,49};
        
    //排序
    quickSort(array, 0, array.length - 1);
        
    //輸出
    System.out.println(Arrays.toString(array));
        
}

private static void quickSort(int[] array, int lowIndex, int highIndex) {
    int lo = lowIndex;
    int hi = highIndex;
    int mid;
    if(highIndex > lowIndex){
        mid = array[(lowIndex + highIndex) / 2];
        while(lo <= hi){
            while((lo < highIndex) && (array[lo] < mid)){
                ++lo;
            }
            while(hi > lowIndex && array[hi] >mid){
                --hi;
            }
            if(lo <= hi){
                swap(array,lo,hi);
                ++lo;
                --hi;
            }
        }
        if(lowIndex <hi){
            quickSort(array, lowIndex, hi);
        }
        if(lo < highIndex){
            quickSort(array, lo, highIndex);
        }
    }
}

private static void swap(int[] array, int lo, int hi) {
    int temp = array[lo];
    array[lo] = array[hi];
    array[hi] = temp;
}

　　本博文路徑：http://www.cnblogs.com/BlueStarWei/p/6853050.html