常用排序算法总结

基于SteveWang的常用排序算法总结文章，链接有更直观的动图展示。本文章对其中的代码实现细节进行优化，方便复习查阅。

1. 冒泡排序

    void bubbleSort(int a[], int size){
        int n = size - 1;
        for(int i = 0; i < n; i++){
            for(int j = n; j > i; j--){
                if(a[j] < a[j-1]){
                    swap(&a[j], &a[j-1]);
                }
            }
        }
    }

2. 选择排序

    void selectSort(int a[], int size){
        int n = size - 1;
        int min;
        for(int i = 0; i < n; i++){
            min = i;
            for(int j = i + 1; j < size; j++){
                if(a[j] < a[min])
                    min = j;
            }
            swap(&a[i], &a[min]);   
        }
    }

3. 插入排序

    void insertSort(int a[], int size){
        int n = size - 1;
        int obj;
        int j;
        for(int i = 1; i <= n; i++){
            obj = a[i];
            j = i-1
            for(; j >= 0; j--)
                if(obj < a[j]) a[j+1] = a[j]; 
                else break;
            a[j+1] = obj;    //细心：j+1
        }
    }

4. 希尔排序

    void shellSort(int a[], int size){
        //int n = sizeof(A) / sizeof(int);
        int i, j, get;
        int h = 0;
        while (h <= n)                    // 生成初始增量
        {
            h = 3*h + 1;
        }
        while (h >= 1)
        {
            for (i = h; i < n; i++)
            {
                j = i - h;
                get = A[i];
                while ((j >= 0) && (A[j] > get))
                {
                    A[j + h] = A[j];
                    j = j - h;
                }
                A[j + h] = get;
            }
            h = (h - 1) / 3;             // 递减增量
        }
    }

5. 归并排序

void merge(int a[], int left, int mid, int right){
    int ln = mid - left + 1;
    int rn = right - mid;
    int l[ln+1];
    int r[rn+1];
    for(int i = 0; i < ln; i++){
        l[i] = a[left+i];
    }
    for(int i = 0;i < rn; i++){
        r[i] = a[mid+1+i];
    }
    l[ln] = INT_MAX;
    r[rn] = INT_MAX;
    int m  = 0, n = 0;
    for(int i = left; i <= right; i++){
        if(l[m] < r[n]){
            a[i] = l[m];
            m++;
        } else {
            a[i] = r[n];
            n++;
        }
    }
}
//边界问题：函数参数含义需要非常清晰
void mergeSort(int a[], int left, int right){
    int mid = (left + right)/2;
    if(left < right){
        mergeSort(a, left, mid);
        mergeSort(a, mid+1, right);
        merge(a, left, mid, right);
    }
}

6. 堆排序

    // 堆数组中对于节点i,其父节点(i - 1)/2 
    // 左子节点i*2+1， 右子节点i*2+2
    void heapDown(int a[], int root, int size){
        int child = root*2 + 1;
        int rChild = child + 1;
        if(child < size){
            if(rChild < size && a[rChild] > a[child])
                child++;
            if(a[child] > a[root]){
                swap(&a[child], &a[root]);
                heapDown(a, child, size);
            }
        }
    }

    void heapSort(int a[], int size){
        //size/2 为最大非叶子节点
        for(int i = size/2; i >=0; i--){
            heapDown(a, i, size);
        }
        for(int i = size - 1; i > 0; i--){
            swap(&a[0], &a[i]);
            heapDown(a, 0, i);//i 非 i-1
        }
    }

7. 快速排序

void quickSort(int a[], int left, int right){
    if(left < right){
        int key = a[left]; //基准
        int l = left;
        int r = right;
        while(l < r){
            while(a[r] > key && l<r)r--;
            a[l] = a[r];
            while(a[l] <= key && l<r)l++;
            a[r] = a[l];
        }
        a[l] = key;
        quickSort(a, left, l-1);
        quickSort(a, l+1, right);
    }
}