常见排序算法实现

1.快速排序：

class QuickSort {
public:
    int* quickSort(int* A, int n) {
        quickSort(A, 0, n-1);
        return A;
    }
    void quickSort(int* arr, int begin, int end){
        if(begin >= end) return;
        int index = partition(arr, begin, end);
        quickSort(arr, begin, index-1);
        quickSort(arr, index+1, end);
    }
    int partition(int* arr, int begin, int end){
         int pivot=arr[begin];
         while(begin < end){
             while(begin < end && arr[end] > pivot)
                 --end;
             if(begin < end) arr[begin] = arr[end];
             while(begin < end && arr[begin] <= pivot)
                 ++begin;
             if(begin < end) arr[end] = arr[begin];
         }
         arr[begin] = pivot;
         return begin;
     }
};

2. 归并排序

class MergeSort {
public:
    int* mergeSort(int* A, int n) {
        if(n < 2) return A;
        mergeSort(A, 0, n-1);
        return A;
    }
    void mergeSort(int* A, int l, int r){
        if(l == r) return;
        int mid = (l + r) / 2;
        mergeSort(A, l, mid);
        mergeSort(A, mid+1, r);
        merge(A, l, mid, r);
    }
    
    void merge(int* A, int left, int mid, int right){
        int* tmp = new int[right-left+1];
        int l=left, r=mid+1;
        int i=0;
        while(l<=mid && r<=right)
            tmp[i++] = A[l]<=A[r] ? A[l++] : A[r++];
        
        while(l <= mid)
            tmp[i++] = A[l++];
        while(r <= right)
            tmp[i++] = A[r++];
        
        for(int i=0; i<right-left+1; ++i)
            A[left + i] = tmp[i];
    }
};

3. 堆排序

https://www.cnblogs.com/chengxiao/p/6129630.html

class HeapSort {
public:
    int* heapSort(int* arr, int n) {
        // 1.构建大顶堆
        for(int i=n/2-1; i>=0; --i){
            adjustHeap(arr, i, n);  //从第一个非叶子结点从下至上，从右至左调整结构
        }
        //2.调整堆结构+交换堆顶元素与末尾元素
        for(int i=n-1; i>0; --i){
            swap(arr[0], arr[i]);
            adjustHeap(arr, 0, i);
        }
        return arr;
    }
    
    void adjustHeap(int* arr, int pos, int len){
        int parent=arr[pos];  // 取出当前元素
        for(int i=2*pos+1; i<len; i=2*i+1){ // 从k结点的左子结点开始，也就是2k+1处开始
            if(i+1<len && arr[i]<arr[i+1])   // 如果左子结点小于右子结点，i指向右子结点
                ++i;
            if(arr[i] > parent){   //如果子节点大于父节点，将子节点值赋给父节点（不用进行交换）
                arr[pos] = arr[i];
                pos = i;
            }else
                break;
        }
        arr[pos] = parent;
    }
};

4. 希尔排序

class ShellSort {
public:
    int* shellSort(int* A, int n) {
        for(int gap=n/2; gap>=1; gap/=2){
            for(int i=gap; i<n; ++i){
                int j=i;
                while(j-gap>=0 && A[j-gap]>A[j]){
                    swap(A[j-gap], A[j]);
                    j-=gap;
                }
            }
        }
        return A;
    }
};

5. 计数排序

class CountingSort {
public:
    int* countingSort(int* A, int n) {
        int max_v = *max_element(A, A+n);
        int min_v = *min_element(A, A+n);
        int size = max_v - min_v + 1;
        int* count = new int[size]();  // 有括号才有初始值0
        for(int i=0; i<n; ++i){
            ++count[A[i] - min_v];
        }
        
        int j=0;
        for(int i=0; i<size; ++i){
            while(count[i]--)
                A[j++] = min_v + i;
        }
        return A;
    }
};