常用排序算法小結

常用排序算法小結

聲明

文章均爲本人技術筆記，轉載請註明出處：
[1] https://segmentfault.com/u/yzwall
[2] blog.csdn.net/j_dark/

排序說明

• 排序算法默認升序排序
• 測試題目lintcode Sort Integers和lintcode Sort IntegersⅡ（要求O(n×logn) 時間複雜度）
• 代碼簡潔起見，提供交換方法swap：

    private void swap(int[] A, int index1, int index2) {
        if (index1 == index2) {
            return;
        }
        int temp = A[index1];
        A[index1] = A[index2];
        A[index2] = temp;
    }

1 選擇排序

“選擇”：選擇排序實現方式最簡單，每次排序將A[i] A[A.length−1] 中的最小值A[minIndex] 與A[i] 交換位置，選擇（最小值）與輸入無關，效率最慢；

/**
 * 選擇排序（升序）
 * 時間複雜度O(n^2)，空間複雜度O(1)
 * @author yzwall
 */
class Solution {
    public void sortIntegers(int[] A) {
        for (int i = 0; i < A.length; i++) {
            int minIndex = i;
            for (int j = i + 1; j < A.length; j++) {
                minIndex = A[minIndex] > A[j] ? j : minIndex;
            }
            swap(A, i, minIndex);
        }
    }
}

2 冒泡排序

“冒泡”：每次冒泡將最大值（升序）移動到當前排序數組區間的最後一位，即向右冒泡，因此A[j−1] 始終維護冒泡區間中的極大值；

/**
 * 冒泡排序（升序）
 * 時間複雜度O(n^2)，空間複雜度O(1)
 * @author yzwall
 */
class Solution {
    public void sortIntegers(int[] A) {
        // i負責維護冒泡區間右邊界爲A[i - 1]
        for (int i = A.length; i > 0; i--) {
            // 冒泡區間爲A[0]~A[i - 1]，最大值冒泡到末位置（升序）
            for (int j = 1; j < i; j++) {
                if (A[j - 1] > A[j]) {
                    swap(A, j, j - 1);
                }
            }
            // 一遍冒泡後，A[i - 1]爲數組A[0] ~ A[i - 1]中最大值
        }
    }
}

3 直接插入排序

“插入”：每次將待排序元素插入到左側的有序（升序）列中，即向左插入， A[j] 始終維護插入元素在有序列中的位置；

/**
 * 直接插入排序（升序）
 * 時間複雜度O(n^2)，空間複雜度O(1)
 * @author yzwall
 */
class Solution {
    public void sortIntegers(int[] A) {
        // 將A[i]~A[A.length - 1]每個數插入到左側的有序列中
        for (int i = 1; i < A.length; i++) {
            for (int j = i; j > 0; j--) {
                if (A[j] < A[j - 1]) {
                    swap(A, j, j - 1);
                }
            }
        }
    }
}

4 希爾排序

待補充；

4 歸併排序

歸併排序小結鏈接

/**
 * http://www.lintcode.com/en/problem/sort-integers-ii/
 * 歸併排序一個整型數組（升序）
 * @author yzwall
 */
class Solution {
    public void sortIntegers2(int[] A) {
        if (A == null || A.length == 0) {
            return;
        }

        mergeSort(A, 0, A.length - 1);
    }

    public void mergeSort(int[] A, int start, int end) {
        if (start >= end) {
            return;
        }
        int mid = start + (end - start) / 2;
        mergeSort(A, start, mid);
        mergeSort(A, mid + 1, end);
        merge(A, start, end);
    }

    private void merge(int[] A, int start, int end) {
        int mid = start + (end - start) / 2;
        int i = start, j = mid + 1, index = 0;
        int[] temp = new int[end - start + 1];
        while (i <= mid && j <= end) {
            if (A[i] < A[j]) {
                temp[index++] = A[i++];
            } else {
                temp[index++] = A[j++];
            }
        }
        while (i <= mid) {
            temp[index++] = A[i++];
        } 
        while (j <= end) {
            temp[index++] = A[j++];
        }
        for (int k = 0; k < index; k++) {
            A[start + k] = temp[k];
        }
    }
}

5 快速排序

快速排序小結鏈接

/**
 * http://www.lintcode.com/en/problem/sort-integers-ii/
 * 快速排序一個整型數組（升序）
 * @author yzwall
 */
class Solution {
    public void sortIntegers2(int[] A) {
        if (A == null || A.length == 0) {
            return;
        }

        quickSort(A, 0, A.length - 1);
    }

    public void quickSort(int[] A, int start, int end) {
        if (start >= end) {
            return;
        }
        int pivot = A[start + (end - start) / 2];
        int left = start, right = end;
        while (left <= right) {
            while (left <= right && A[left] < pivot) {
                left++;
            }
            while (left <= right && A[right] > pivot) {
                right--;
            }
            if (left <= right) {
                int temp = A[left];
                A[left] = A[right];
                A[right] = temp;
                left++;
                right--;
            }
        }
        quickSort(A, start, right);
        quickSort(A, left, end);
    }
}

6 堆排序

堆實現小結鏈接

6 桶排序

待補充；

7 計數排序

待補充；