三大排序算法(快速排序，归并排序，堆排序)

1）快速排序

int partition(int* pData, int start, int end){   
    int pivot = pData[end];
    while (start < end){
        while (start < end && pData[start] <= pivot)    start++;
        pData[end] = pData[start];
        
        while (start < end && pData[end] >= pivot)  end--;
        pData[start] = pData[end];
    }
    pData[start] = pivot;
    return start;
}

void quickSort(int* pData, int start, int end){
    if (!pData || start >= end) return;
    
    int mid = partition(pData, start, end);
    quickSort(pData, start, mid - 1);
    quickSort(pData, mid + 1, end);
}

void quickSort(int* pData, int n){
    quickSort(pData, 0, n - 1);
}

2）归并排序

void merge(int* pData, int* pCopy, int start, int mid, int end){
    int i = start, j = mid + 1, k = start;
    while (i <= mid && j <= end){
        if (pData[i] < pData[j])
            pCopy[k++] = pData[i++];
        else
            pCopy[k++] = pData[j++];
    }
    
    while (i <= mid)    pCopy[k++] = pData[i++];
    while (j <= end)    pCopy[k++] = pData[j++];
    
    memcpy(pData + start, pCopy + start, sizeof(int) * (end - start + 1));
}

void mergeSort(int* pData, int* pCopy, int start, int end){
    if (start >= end)   return;
    
    int mid = start + (end - start) / 2;
    mergeSort(pData, pCopy, start, mid);
    mergeSort(pData, pCopy, mid + 1, end);
    merge(pData, pCopy, start, mid, end);
}

void mergeSort(int* pData, int n){
    if (!pData || n <= 0)   return;
    int* pCopy = new int[n];
    mergeSort(pData, pCopy, 0, n - 1);
    delete [] pCopy;
}

3）堆排序

void heapAdjust(int* pData, int start, int end){
    int t = pData[start];
    for (int i = 2 * start + 1; i <= end; i++){
        if (i < end && pData[i] < pData[i + 1]) i++;
        if (pData[i] < t)   break;
        pData[start] = pData[i];
        start = i;
    }
    pData[start] = t;
}

void heapSort(int* pData, int n){
    for (int i = n / 2; i >= 0; i--){
        heapAdjust(pData, i, n - 1);
    }
    
    for (int i = n - 1; i > 0; i--){
        swap(pData[i], pData[0]);
        heapAdjust(pData, 0, i - 1);
    }
}

测试：

#include <iostream>
#include <cstring>
using namespace std;

void heapAdjust(int* pData, int start, int end){
    int t = pData[start];
    for (int i = 2 * start + 1; i <= end; i++){
        if (i < end && pData[i] < pData[i + 1]) i++;
        if (pData[i] < t)   break;
        pData[start] = pData[i];
        start = i;
    }
    pData[start] = t;
}

void heapSort(int* pData, int n){
    for (int i = n / 2; i >= 0; i--){
        heapAdjust(pData, i, n - 1);
    }
    
    for (int i = n - 1; i > 0; i--){
        swap(pData[i], pData[0]);
        heapAdjust(pData, 0, i - 1);
    }
}

int partition(int* pData, int start, int end){   
    int pivot = pData[end];
    while (start < end){
        while (start < end && pData[start] <= pivot)    start++;
        pData[end] = pData[start];
        
        while (start < end && pData[end] >= pivot)  end--;
        pData[start] = pData[end];
    }
    pData[start] = pivot;
    return start;
}

void quickSort(int* pData, int start, int end){
    if (!pData || start >= end) return;
    
    int mid = partition(pData, start, end);
    quickSort(pData, start, mid - 1);
    quickSort(pData, mid + 1, end);
}

void quickSort(int* pData, int n){
    quickSort(pData, 0, n - 1);
}

void merge(int* pData, int* pCopy, int start, int mid, int end){
    int i = start, j = mid + 1, k = start;
    while (i <= mid && j <= end){
        if (pData[i] < pData[j])
            pCopy[k++] = pData[i++];
        else
            pCopy[k++] = pData[j++];
    }
    
    while (i <= mid)    pCopy[k++] = pData[i++];
    while (j <= end)    pCopy[k++] = pData[j++];
    
    memcpy(pData + start, pCopy + start, sizeof(int) * (end - start + 1));
}

void mergeSort(int* pData, int* pCopy, int start, int end){
    if (start >= end)   return;
    
    int mid = start + (end - start) / 2;
    mergeSort(pData, pCopy, start, mid);
    mergeSort(pData, pCopy, mid + 1, end);
    merge(pData, pCopy, start, mid, end);
}

void mergeSort(int* pData, int n){
    if (!pData || n <= 0)   return;
    int* pCopy = new int[n];
    mergeSort(pData, pCopy, 0, n - 1);
    delete [] pCopy;
}

int main(){
    int a1[10] = {5, 6, 4, 3, 3, 1, 2, 5, 7, 8};
    int a2[10] = {5, 6, 4, 3, 3, 1, 2, 5, 7, 8};
    int a3[10] = {5, 6, 4, 3, 3, 1, 2, 5, 7, 8};
    
    quickSort(a1, 10);
    for (int i = 0; i < 10; i++)    cout << a1[i] << " ";
    cout << endl;
    
    heapSort(a2, 10);
    for (int i = 0; i < 10; i++)    cout << a2[i] << " ";
    cout << endl;
    
    mergeSort(a3, 10);
    for (int i = 0; i < 10; i++)    cout << a3[i] << " ";
    cout << endl;
    
    return 0;
}