排序备忘

#ifndef SORT_H
#define SORT_H

#ifndef max
#define max(a, b) ((a) > (b) ? (a) : (b))
#endif

#include <memory>
#include <string.h>
using namespace std;

/***********************插入排序************************/
// 插入排序 稳定 time: O(n2) space: O(1)
void InsertSort(int R[], int n) {
    int i, j;
    int temp;
    for (i = 1; i < n; i++) {
        temp = R[i];
        j = i - 1;
        while (j >= 0 && R[j] > temp) {
            R[j + 1] = R[j];
            j--;
        }
        R[j + 1] = temp;
    }
}

// 折半插入排序 稳定 time: O(nlgn) space: O(1)
void BInsertSort(int R[], int n) {
    int low, high, mid;
    int temp;
    for (int i = 1; i < n; i++) {
        temp = R[i];
        low = 0;
        high = i - 1;
        while (low <= high) {
            mid = low + (high - low) / 2;
            // 注意这里是小于而不是小于等于，保证排序算法的稳定性
            if (temp < R[i]) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        for (int j = i - 1; j >= low; j--) {
            R[j + 1] = R[j];
        }
        R[low] = temp;
    }
}

// 希尔排序(增量排序) 不稳定 time: O(n1.5)--O(n2)
void InsertSort_Gap(int R[], int n, int start, int gap) {
    int temp, i, j;
    for (i = start + gap; i < n; i += gap) {
        if (R[i] < R[i - gap]) {
            temp = R[i];
            j = i;
            do {
                R[j] = R[j - gap];
                j -= gap;
            } while (j - gap > 0 && R[j - gap] > temp);
            R[j] = temp;
        }
    }
}
void ShellSort(int R[], int Gap[], int n, int m) {
    int i, start, gap;
    for (i = m - 1; i >= 0; i--) {
        gap = Gap[i];
        for (start = 0; start < gap; start++) {
            InsertSort_Gap(R, n, start, gap);
        }
    }
}


/***********************交换类排序************************/
// 冒泡排序 稳定 time: O(n) space: O(1)
void BubbleSort(int R[], int n) {
    int i, j, flag;
    int temp;
    for (i = n - 1; i >= 1; i--) {
        flag = 0;
        for (int j = 0; j < i; j++) {
            if (R[j] > R[j + 1]) {
                temp = R[j];
                R[j] = R[j + 1];
                R[j + 1] = temp;
                flag = 1;
            }
        }
        if (flag == 0) {
            return;
        }
    }
}

// 快速排序 不稳定 time: O(nlgn) space: O(n)
void QuickSort(int R[], int low, int high) {
    int temp;
    int i = low, j = high;
    while (low < high) {
        temp = R[low];
        while (i < j) {
            while (j > i && R[j] > temp) {
                j--;
            }
            if (i < j) {
                R[i] = R[j];
                i++;
            }
            while (i < j && R[i] < temp) {
                i++;
            }
            if (i < j) {
                R[j] = R[i];
                j--;
            }
        }
        R[i] = temp;
        QuickSort(R, low, i - 1);
        QuickSort(R, i + 1, high);
    }
}

/***********************选择类排序************************/
// 简单选择排序 不稳定 time: O(n2) space: O(1)
void SelectSort(int R[], int n) {
    int i, j, k;
    int temp;
    for (i = 0; i < n - 1; i++) {
        k = i;
        for (j = i + 1; j < n; j++) {
            if (R[k] > R[j]) {
                k = j;
            }
        }
        temp = R[i];
        R[i] = R[k];
        R[k] = temp;
    }
}

// 堆排序 不稳定 time: O(nlng) space: O(1)
void Sift(int R[], int low, int high) {
    int i = low, j = 2 * i, temp;
    while (j <= high) {
        if (j < high && R[j] < R[j + 1]) {
            j++;
        }
        if (R[i] < R[j]) {
            temp = R[i];
            R[i] = R[j];
            R[j] = temp;
            i = j;
            j = 2 * i;
        } else {
            break;
        }
    }
}

void HeapSort(int R[], int n) {
    int i;
    int temp;
    for (i = n / 2; i > 0; i--) {
        Sift(R, i, n);
    }
    for (i = n; i >= 2; i--) {
        temp = R[1];
        R[1] = R[i];
        R[i] = R[1];
        Sift(R, 1, i - 1);
    }
}

// 归并排序 稳定 time: O(nlng) space: O(n)
void Merge(int R[], int low, int mid, int high) {
    int i = low, j = mid + 1, k = 0;
    int *L = (int *)malloc(sizeof(int) * (high + 1 - low));
    while (i <= mid && j <= high) {
        if (R[i] <= R[j]) {
            L[k++] = R[i++];
        } else {
            L[k++] = R[j++];
        }
    }
    while (i <= mid) {
        L[k++] = R[i++];
    }
    while (j <= high) {
        L[k++] = R[j++];
    }
    for (i = 0; i < high + 1 - low; i++) {
        R[i] = L[low + i];
    }
    free(L);
}

void MergeSort(int R[], int low, int high) {
    if (low < high) {
        int mid = low + (high - low) / 2;
        MergeSort(R, low, mid);
        MergeSort(R, mid + 1, high);
        Merge(R, low, mid, high);
    }
}

// 基数排序 稳定
void CountSort(int R[], int ans[], int n) {
    // assume elements in arr are all non-negtive
    int K = 0;
    for (int i = 0; i < n; i++) {
        K = max(K, R[i]);
    }
    int count[K + 1];
    memset(count, 0, sizeof count);
    for (int i = 0; i < n; i++) {
        count[R[i]] = count[R[i]] + 1;
    }
    int k = 0;
    for (int i = 0; i <= K; i++) {
        for (int j = 0; j < count[R[i]]; j++) {
            ans[k++] = count[R[i]];
        }
    }
}
#endif // SORT_H

/*******************************************************************
 * 总结：
 * 对一个初始状态为递增的序列进行递增排序，用直接插入排序最省时，用快速排序最费时
 * 交换类和选择类的排序每趟结束都有一个关键字到位
 * 排序趟数与初试状态无关的是选择排序，有关的是冒泡排序
 ******************************************************************/