幾種排序的總結

冒泡法排序

• 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
• 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
• 針對所有的元素重複以上的步驟，除了最後一個.
• 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

 * @param numbers  
 *  需要排序的整型數組  
 */  
public static void bubbleSort(int[] numbers) {   
    int temp; // 記錄臨時中間值   
    int size = numbers.length; // 數組大小   
    for (int i = 0; i < size - 1; i++) {   
        for (int j = i + 1; j < size; j++) {   
            if (numbers[i] < numbers[j]) { // 交換兩數的位置   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
            }   
        }   
    }   
}

快速排序

• 從數列中挑出一個元素，稱爲“基準
• 重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分割之後，
• 該基準是它的最後位置。這個稱爲分割（partition）操作。
• 遞歸地把小於基準值元素的子數列和大於基準值元素的子數列排序。

/
 *   
 * @param numbers  
 * @param start  
 * @param end  
 */  
public static void quickSort(int[] numbers, int start, int end) {   
    if (start < end) {   
        int base = numbers[start]; // 選定的基準值（第一個數值作爲基準值）   
        int temp; // 記錄臨時中間值   
        int i = start, j = end;   
        do {   
            while ((numbers[i] < base) && (i < end))   
                i++;   
            while ((numbers[j] > base) && (j > start))   
                j--;   
            if (i <= j) {   
                temp = numbers[i];   
                numbers[i] = numbers[j];   
                numbers[j] = temp;   
                i++;   
                j--;   
            }   
        } while (i <= j);   
        if (start < j)   
            quickSort(numbers, start, j);   
        if (end > i)   
            quickSort(numbers, i, end);   
    }   
}

選擇排序

• 在未排序序列中找到最小元素，存放到排序序列的起始位置
• 再從剩餘未排序元素中繼續尋找最小元素，然後放到排序序列末尾。
• 以此類推，直到所有元素均排序完畢

/
 *   
 * @param numbers  
 */  
public static void selectSort(int[] numbers) {   
    int size = numbers.length, temp;   
    for (int i = 0; i < size; i++) {   
        int k = i;   
        for (int j = size - 1; j >i; j--)  {   
            if (numbers[j] < numbers[k])  k = j;   
        }   
        temp = numbers[i];   
        numbers[i] = numbers[k];   
        numbers[k] = temp;   
    }   
}

插入排序

• 從第一個元素開始，該元素可以認爲已經被排序
• 取出下一個元素，在已經排序的元素序列中從後向前掃描
• 如果該元素（已排序）大於新元素，將該元素移到下一位置
• 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
• 將新元素插入到該位置中
• 重複步驟2

/
 *   
 * @param numbers  
 */  
public static void insertSort(int[] numbers) {   
    int size = numbers.length, temp, j;   
    for(int i=1; i<size; i++) {   
        temp = numbers[i];   
        for(j = i; j > 0 && temp < numbers[j-1]; j--)   
            numbers[j] = numbers[j-1];   
        numbers[j] = temp;   
    }   
}

歸併排序

• 申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列
• 設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置
• 比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一位置
• 重複步驟3直到某一指針達到序列尾
• 將另一序列剩下的所有元素直接複製到合併序列尾

  /
 *   
 * @param numbers  
 */  
public static void mergeSort(int[] numbers, int left, int right) {   
    int t = 1;// 每組元素個數   
    int size = right - left + 1;   
    while (t < size) {   
        int s = t;// 本次循環每組元素個數   
        t = 2 * s;   
        int i = left;   
        while (i + (t - 1) < size) {   
            merge(numbers, i, i + (s - 1), i + (t - 1));   
            i += t;   
        }   
        if (i + (s - 1) < right)   
            merge(numbers, i, i + (s - 1), right);   
    }   
}   

歸併算法

/**  
 * 歸併算法實現  
 *   
 * @param data  
 * @param p  
 * @param q  
 * @param r  
 */  
private static void merge(int[] data, int p, int q, int r) {   
    int[] B = new int[data.length];   
    int s = p;   
    int t = q + 1;   
    int k = p;   
    while (s <= q && t <= r) {   
        if (data[s] <= data[t]) {   
            B[k] = data[s];   
            s++;   
        } else {   
            B[k] = data[t];   
            t++;   
        }   
        k++;   
    }   
    if (s == q + 1)   
        B[k++] = data[t++];   
    else  
        B[k++] = data[s++];   
    for (int i = p; i <= r; i++)   
        data[i] = B[i];   
}