排序算法

常用的几个排序

冒泡排序

void BubbleSort(vector<int>& vec)
{
    for (int i = 0; i < vec.size() -1 ; i++) {
        for (int j = 0; j < vec.size() - 1; j++) {
            if (vec[j] < vec[j+1]) {
                swap(vec[j], vec[j+1]);
            }
        }
        for (auto i : vec) {
            cout << i << " ";
        }
        cout << endl;
    }
}

插入排序

void InsertSort(vector<int>& vec)
{
    for (int i = 1; i < vec.size(); i++) {
        int value = vec[i];
        int j = i - 1;
        for (; j >=0; j--) {
            if (vec[j] > value) {
                vec[j+1] = vec[j];
            } else {
                break;
            }
        }
        vec[j+1] = value;
        for (auto i : vec) {
            cout << i << " ";
        }
        cout << endl;
    }
}

选择排序

for (int i = 0; i < vec.size() - 1; i++) {
        int tmp = i;
        for (int j = i + 1; j < vec.size(); j++) {
            if (vec[j] > vec[i]) {
                tmp = j;
            }
        }
        swap(vec[i], vec[tmp]);
        for (auto i : vec) {
            cout << i << " ";
        }
        cout << endl;
    }

归并排序

void Merger(vector<int>& vec, int p, int q, int r)
{
    int i = p;
    int j = q + 1;
    int k = 0;
    unique_ptr<int[]> tmp = make_unique<int[]>(r - p);
    while (i <= q && j <=r) {
        if (vec[i] <= vec[j]) {
            tmp[k++] = vec[i++];
        } else {
            tmp[k++] = vec[j++];
        }
    }

    // 判断哪一半还有剩余数据
    int start = i;
    int end = q;
    if (j <= r) {
        start = j;
        end = r;
    }
    // 将剩余数据拷贝到tmp数组
    while (start <= end) {
        tmp[k++] = vec[start++];
    }

    // 将tmp数据拷贝回[p..r]
    for (int n = 0; n <= r - p; n++) {
        vec[p + n] = tmp[n];
    }
}

/* 递推公式 merge_sort(p...r) = merge(merge_sort(p...q), merge_sort(q+1...r))
 * 终止条件 p>=r 不用再继续分解
 */
void MergeSort(vector<int>& vec, int p, int r)
{
    // 递归终止条件
    if (p >= r) {
        return;
    }

    int q = (p + r) / 2;
    MergeSort(vec, p, q);
    MergeSort(vec, q + 1, r);
    // 合并[p..q]和[[q+1..r]
    Merger(vec, p, q, r);
}

void MergeSort(vector<int>& vec)
{
    MergeSort(vec, 0, vec.size() - 1);
}

快速排序

int Partition(vector<int>& vec, int p, int r)
{
    int pivot = vec[r];
    int i = p; //vec[p..i]为比pivot小的元素, vec[j...r-1]为未比较的元素
    for (int j = p; j <= r-1; j++) { // vec[r]不需要跟自己比较
        if (vec[j] < pivot) {
            swap(vec[i], vec[j]);
            i++; // 找到中间的位置
        }
    }
    // 将pivot插入合适位置
    swap(vec[i], vec[r]);
    return i;
}

/* 递推公式
 * QuickSort(p...r) = QuickSort(p..q-1) + QuickSort(q+1, r)
 * 终止条件 p>=r
 */
void QuickSort(vector<int>&vec, int p, int r)
{
    if (p >= r) {
        return;
    }

    // 获取区分点
    int q = Partition(vec, p, r);
    QuickSort(vec, p, q - 1);
    QuickSort(vec, q + 1, r);
}

void QuickSort(vector<int>& vec)
{
    QuickSort(vec, 0, vec.size() - 1);
}