整理了一下六種排序演算法，分別是：

• 氣泡排序
• 插入排序
• 選擇排序
• 快速排序
• 歸併排序
• 堆排序

程式碼都經過了Lintcode的整數排序題目的測試。如下：

class Solution {
public:
    /**
     * @param A an integer array
     * @return void
     */
    void sortIntegers(vector<int>& A) {
        // Write your code here
        const int len = A.size();
        // bubbleSort(A, len);
 

        // insertSort(A, len);
        // selectSort(A, len);
        // quickSort(A, 0, len-1);
        // mergeSort(A, 0, len-1);
        maxHeapSort(A, len-1);
    }

    void bubbleSort(vector<int>& A, int len)
    {
        for (int i = 0; i < len; i++)
        {
            bool isSwap = false
 
;
            for (int j = 1; j < len - i; j++)
            {
                if (A[j-1] > A[j])
                {
                    swap(A[j-1], A[j]);
                    isSwap = true;
                }
            }
            if (!isSwap)
                return;
        }
    }

    bool
 
 insertSort(vector<int>& A, int len)
    {
        for (int i = 1; i < len; i++)
        {
            for (int j = i; j > 0 && A[j-1] > A[j]; j--)
            {
                swap(A[j-1], A[j]);
            }
        }
    }

    void selectSort(vector<int>& A, int len)
    {
        for (int i = 0; i < len; i++)
        {
            int minIndex = i;
            for (int j = i + 1; j < len; j++)
            {
                if (A[j] < A[minIndex])
                {
                    minIndex = j;
                }
            }
            swap(A[i], A[minIndex]);
        }
    }

    void quickSort(vector<int>& A, int start, int end)
    {
        if (start >= end)
            return;
        int p = partition(A, start, end);
        quickSort(A, start, p-1);
        quickSort(A, p+1, end);
    }

    int partition(vector<int>& A, int start, int end)
    {
        int lo = start;
        int hi = start;
        while (hi < end)
        {
            if (A[hi] < A[end])
            {
                swap(A[hi++], A[lo++]);
            }
            else
            {
                hi++;
            }
        }
        swap(A[lo], A[end]);
        return lo;
    }

    void mergeSort(vector<int>& A, int start, int end)
    {
        if (start >= end)
            return;
        int mid = (start + end) / 2; 
        mergeSort(A, start, mid);
        mergeSort(A, mid+1, end);
        merge(A, start, mid, end);
    }

    void merge(vector<int>& A, int start, int mid, int end)
    {
        int lo = start;
        int hi = mid + 1;
        const int len = end - start + 1;
        int tmp[len];
        int k = 0;
        while (lo <= mid && hi <= end)
        {
            if (A[lo] < A[hi])
            {
                tmp[k++] = A[lo++];
            }
            else
            {
                tmp[k++] = A[hi++];
            }
        }
        while (lo <= mid)
            tmp[k++] = A[lo++];
        while (hi <= end)
            tmp[k++] = A[hi++];
        for (int i = 0; i < k; i++)
            A[start+i] = tmp[i];
    }

    void maxHeapSort(vector<int>& A, int end)
    {
        makeMaxHeap(A, end);
        for (int i = end; i > 0; i--)
        {
            swap(A[0], A[i]);
            maxHeapFixDown(A, 0, i-1);
        }
    }

    void makeMaxHeap(vector<int>& A, int end)
    {
        for (int i = (end - 1) / 2; i >= 0; i--)
        {
            maxHeapFixDown(A, i, end);
        }
    }

    void maxHeapFixDown(vector<int>& A, int start, int end)
    {
        int par = start;
        int maxChild = par * 2 + 1;
        while (maxChild <= end)
        {
            if (maxChild + 1 <= end && A[maxChild] < A[maxChild+1])
                maxChild++;
            if (A[par] > A[maxChild])
                return;
            swap(A[par], A[maxChild]);
            par = maxChild;
            maxChild = par * 2 + 1;
        }
    }
};