排序演算法

穩定性和複雜度

不穩定
（1）選擇排序（selection sort）— O(n2)
（2）快速排序（quicksort）— O(nlogn) 平均時間, O(n2) 最壞情況; 對於大的、亂序串列一般認為是最快的已知排序
（3）堆排序 （heapsort）— O(nlogn)
（4）希爾排序 （shell sort）— O(nlogn)
（5）基數排序（radix sort）— O(n·k); 需要 O(n) 額外儲存空間 （K為特徵個數）
穩定
（1）插入排序（insertion sort）— O(n2)
（2） 氣泡排序（bubble sort） — O(n2)
（3） 歸併排序 （merge sort）— O(n log n); 需要 O(n) 額外儲存空間
（4）二叉樹排序（Binary tree sort） — O(nlogn); 需要 O(n) 額外儲存空間
（5）計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外儲存空間，k為序列中Max-Min+1
（6）桶排序 （bucket sort）— O(n); 需要 O(k) 額外儲存空間

各種排序演算法的具體程式設計實現

氣泡排序

package Sort;

import java.util.Arrays;

public class BubbleSort {
    public static void main(String[] args) {
        int [] a = {1,100,234,44,3,2,4,5};
        bubbleSort(a,a.length+1);
        System.out.println(Arrays.toString(a));
    }
    public static
 
 int[] bubbleSort(int[] A, int n) {

        for (int i=0;i<A.length;i++){
            for (int j=i+1;j<A.length;j++){
                if (A[i] > A[j]){
                    int tmp = A[i];
                    A[i] = A[j];
                    A[j] = tmp;
                }
            }
        }

    return
 
 A;
    }
}

快速排序

package Sort;

import java.util.Arrays;

public class QuickSort {

    public static void main(String[] args) {
        int A[] = {1,6,9, 2, 3, 1, 5, 4 };
        quickSort(A, 0, 7);
        System.out.println(Arrays.toString(A));
    }

    public static void quickSort(int[] A, int left, int right) {

        if (left < right) {
            // 一次劃分
            int mid = partion(A, left, right);
            quickSort(A, 0, mid - 1);
            quickSort(A, mid + 1, right);
        }
    }

    public static void swap(int[] A, int l, int r) {
        int tmp = A[l];
        A[l] = A[r];
        A[r] = tmp;

    }

    public static int partion(int[] a, int left, int right) {
        // 軸值，預設選取陣列的第一個數字
        while (left < right) {
            while (left < right && a[left] <= a[right]) {
                right--;
            }
            if (left<right){
                swap(a, left, right);
            }
            while (left < right && a[left] <= a[right]) {
                left++;
            }
            if (left<right){
                swap(a, left, right);
            }
        }
        return left;
    }

}

插入排序

package Sort;

public class InsertionSort {
    public int[] insertionSort(int[] A, int n) {
        int i, j, temp;

        for(i = 1; i < n; i++){
            temp = A[i];
            for(j = i; j > 0 && A[j - 1] > temp; j-- ){
                A[j] = A[j - 1];
            }
            A[j] = temp;
        }

        return A;
    }
}

希爾排序

package Sort;

import java.util.Arrays;

public class ShellSort {

    public static void main(String[] args) {
        int[] a = { 54, 35, 48, 36, 27, 12, 44, 44, 8, 14, 26, 17, 28 };
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a) {
        // 設定步長，預設為陣列長度的一半
        int step = a.length / 2;
        while (step >= 1) {
            for (int i = step; i < a.length; i += step) {
                int tmp = a[i];
                int j;
                for (j = i; j > 0 && a[j - step] > tmp; j -= step) {
                    a[j] = a[j - step];//元素後移
                }
                a[j] = tmp;//插入的位置，注意此時j在for迴圈中已經進行了一次--
            }
            step /= 2;
        }
    }

}

選擇排序

package Sort;

public class SelectionSort {
    public int[] selectionSort(int[] A, int n) {
        // write code here
        for (int i = 0; i < n - 1; i++) {
            int index = i;
            int j;
            // 找出最小值得元素下標
            for (j = i + 1; j < n; j++) {
                if (A[j] < A[index]) {
                    index = j;
                }
            }
            int tmp = A[index];
            A[index] = A[i];
            A[i] = tmp;
        }
        return A;
    }
}

歸併排序

package Sort;


public class MergeSort {

    public static void main(String[] args) {

        int[] A = { 1, 4, 3, 2, 5 };
        mergeSort(A, 5);
        for (int i = 0; i < A.length; i++) {
            System.out.println(A[i]);

        }
    }

    public static int[] mergeSort(int[] A, int n) {
        // write code here
        sort(A, 0, n - 1);
        return A;
    }

    public static void sort(int[] A, int left, int right) {
        if (left < right) {
            int mid = (left + right) / 2;
            sort(A, left, mid);
            sort(A, mid + 1, right);
            merge(A, left, mid, right);
        }
    }

    public static void merge(int[] A, int left, int mid, int right) {
        // 臨時陣列

        int n = right - left + 1;
        int[] tmpArr = new int[n];
        int l = left;
        int r = mid + 1;
        int t = 0;// 臨時陣列下標元素

        // 比較兩子序列元素的大小
        while (l <= mid && r <= right) {
            if (A[l] < A[r]) {
                tmpArr[t++] = A[l++];
            } else {
                tmpArr[t++] = A[r++];
            }
        }

        // 剩餘的加入臨時陣列
        while (l <= mid) {
            tmpArr[t++] = A[l++];
        }
        // 剩餘的加入臨時陣列
        while (r <= right) {
            tmpArr[t++] = A[r++];
        }

        // 把臨時陣列元素放回原陣列
        for (int i = 0; i < t; i++) {
            A[left + i] = tmpArr[i];
        }

    }
}

堆排序

package Sort;

import java.util.Arrays;

public class HeapSort {

    public static void main(String[] args) {
        int[] a = { 2, 5, 9, 6, 1, 4, 8, 7, 12, 50 };
        sort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void sort(int[] a) {
        int len = a.length;
        for (int i = 0; i < len - 1; i++) {
            // 建堆
            buildHeap(a, len - 1 - i);
            // 交換堆頂元素和最後一個元素
            swap(a, 0, len - 1 - i);
        }
    }

    private static void swap(int[] a, int i, int j) {
        // TODO Auto-generated method stub
        int tmp = a[i];
        a[i] = a[j];
        a[j] = tmp;

    }

    public static void buildHeap(int[] a, int lastIndex) {
        // 從最後一個節點的父節點開始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // 當前節點存在子節點
            while (i * 2 + 1 <= lastIndex) {
                // 左節點下標值
                int l = i * 2 + 1;
                // 右結點下標值
                int r = i * 2 + 2;

                // 預設左節點為最大值
                int biggerIndex = l;
                // 存在右結點
                if (l < lastIndex) {
                    // 右結點的值比左節點大
                    if (a[r] > a[l]) {
                        biggerIndex = r;
                    }
                }
                // 當前節點的值比孩子節點的最小值小，交換
                if (a[i] < a[biggerIndex]) {
                    swap(a, i, biggerIndex);
                    // 把最大值下標賦給當前節點，進入下一次while迴圈判斷
                    i = biggerIndex;
                } else {
                    break;
                }

            }

        }
    }

}

計數排序

package sort;
public class CountSort {

    private static int[] countSort(int[] array,int k)
    {
        int[] C=new int[k+1];//構造C陣列
        int length=array.length,sum=0;//獲取A陣列大小用於構造B陣列  
        int[] B=new int[length];//構造B陣列
        for(int i=0;i<length;i++)
        {
            C[array[i]]+=1;// 統計A中各元素個數，存入C陣列
        }
        for(int i=0;i<k+1;i++)//修改C陣列
        {
            sum+=C[i];
            C[i]=sum;    
        }
        for(int i=length-1;i>=0;i--)//遍歷A陣列，構造B陣列
        {

            B[C[array[i]]-1]=array[i];//將A中該元素放到排序後陣列B中指定的位置
            C[array[i]]--;//將C中該元素-1，方便存放下一個同樣大小的元素

        }
        return B;//將排序好的陣列返回，完成排序

    }
    public static void main(String[] args)
    {
        int[] A=new int[]{2,5,3,0,2,3,0,3};
        int[] B=countSort(A, 5);
        for(int i=0;i<A.length;i++)
        {
            System.out.println((i+1)+"th:"+B[i]);
        }
    }
}

基數排序

package sort;

public class RadixSort {
private static void radixSort(int[] array,int d)
{
    int n=1;//代表位數對應的數：1,10,100...
    int k=0;//儲存每一位排序後的結果用於下一位的排序輸入
    int length=array.length;
    int[][] bucket=new int[10][length];//排序桶用於儲存每次排序後的結果，這一位上排序結果相同的數字放在同一個桶裡
    int[] order=new int[length];//用於儲存每個桶裡有多少個數字
    while(n<d)
    {
        for(int num:array) //將陣列array裡的每個數字放在相應的桶裡
        {
            int digit=(num/n)%10;
            bucket[digit][order[digit]]=num;
            order[digit]++;
        }
        for(int i=0;i<length;i++)//將前一個迴圈生成的桶裡的資料覆蓋到原陣列中用於儲存這一位的排序結果
        {
            if(order[i]!=0)//這個桶裡有資料，從上到下遍歷這個桶並將資料儲存到原陣列中
            {
                for(int j=0;j<order[i];j++)
                {
                    array[k]=bucket[i][j];
                    k++;
                }
            }
            order[i]=0;//將桶裡計數器置0，用於下一次位排序
        }
        n*=10;
        k=0;//將k置0，用於下一輪儲存位排序結果
    }

}
public static void main(String[] args)
{
    int[] A=new int[]{73,22, 93, 43, 55, 14, 28, 65, 39, 81};
    radixSort(A, 100);
    for(int num:A)
    {
        System.out.println(num);
    }
}
}

堆排序

//構建大根堆：將array看成完全二叉樹的順序儲存結構
    private int[] buildMaxHeap(int[] array){
        //從最後一個節點array.length-1的父節點（array.length-1-1）/2開始，直到根節點0，反覆調整堆
        for(int i=(array.length-2)/2;i>=0;i--){ 
            adjustDownToUp(array, i,array.length);
        }
        return array;
    }

    //將元素array[k]自下往上逐步調整樹形結構
    private void adjustDownToUp(int[] array,int k,int length){
        int temp = array[k];   
        for(int i=2*k+1; i<length-1; i=2*i+1){    //i為初始化為節點k的左孩子，沿節點較大的子節點向下調整
            if(i<length && array[i]<array[i+1]){  //取節點較大的子節點的下標
                i++;   //如果節點的右孩子>左孩子，則取右孩子節點的下標
            }
            if(temp>=array[i]){  //根節點 >=左右子女中關鍵字較大者，調整結束
                break;
            }else{   //根節點 <左右子女中關鍵字較大者
                array[k] = array[i];  //將左右子結點中較大值array[i]調整到雙親節點上
                k = i; //【關鍵】修改k值，以便繼續向下調整
            }
        }
        array[k] = temp;  //被調整的結點的值放人最終位置
    }