排序算法總結

排序算法總結

1.幾種基本的代碼實現

冒泡排序：

 /**
     * 冒泡排序
     * @param arr 待排序數組
     * @return
     */
 public void BubbleSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            for (int j = 0; j < arr.length - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    int t = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = t;
                }
            }
        }
    }

快速排序：

/**
     * 快速排序
     * @param arr   待排數組
     * @param start 下標
     * @param end   上標
     */
    public void QuickSort(int[] arr, int start, int end) {
        if (start > end)
            return;
        //下標
        int low = start;
        //上標
        int high = end;
        //基準數
        int temp = arr[start];

        while (low < high) {
            while (temp <= arr[high] && low < high)
                high--;
            while (temp >= arr[low] && low < high)
                low++;
            if (low < high) {
                int t = arr[high];
                arr[high] = arr[low];
                arr[low] = t;
            }
        }

        arr[start] = arr[low];
        arr[low] = temp;

        QuickSort(arr, start, high - 1);
        QuickSort(arr, high + 1, end);
    }

插入排序：

/**
     * 插入排序
     * @param arr 待排數組
     */
    public void InsertSort(int[] arr) {
        int len = arr.length;
        if (arr.length <= 1)
            return;
        for (int i = 1; i < len; i++) {
            int temp = arr[i];
            for (int j = 0; j < i; j++) {
                if (arr[j] > temp) {
                    int t = i;
                    while (t > j) {
                        arr[t] = arr[t - 1];
                        t--;
                    }
                    arr[j] = temp;
                    break;
                }
            }
        }
    }

選擇排序：

/**
     * 選擇排序
     * @param arr 待排數組
     */
    public void SelectSort(int[] arr) {
        int len = arr.length;
        int minindex = 0;
        for (int i = 0; i < len; i++) {
            int min = 10000000;
            for (int j = i; j < len; j++) {
                if (arr[j] < min) {
                    min = arr[j];
                    minindex = j;
                }
            }
            int temp = arr[i];
            arr[i] = arr[minindex];
            arr[minindex] = temp;
        }
    }

2.幾種基本的排序算法比較

排序算法	時間複雜度	穩定性	特點
冒泡排序	O(n2)	穩定	一般情況下，特別是在逆序時，它很不理想。它是對數據有序性非常敏感的排序算法。
插入排序	O(n2)	穩定	插入排序將要優於冒泡排序。直接插入法也是一種對數據的有序性非常敏感的一種算法。在有序情況下只需要經過n-1次比較，在最壞情況下，將需要n(n-1)/2次比較
選擇排序	O(n2)	不穩定	對數據的有序性不敏感。它雖然比較次數多，但它的數據交換量卻很少。所以我們將發現它在一般情況下將快於冒泡排序
快速排序	O(nlogn) 平均時間, O(n2) 最壞情況	不穩定	在理論上講，如果每次能均勻劃分序列，它將是最快的排序算法， 因此稱它作快速排序。雖然很難均勻劃分序列，但就平均性能而言，它仍是基於關鍵字比較的內部排序算法中速度最快者。
堆排序	O(nlogn)	不穩定	一般在小規模的序列中不合適，但對於較大的序列，將表現出優越的性能