开坑（

#include<iostream>
#include<algorithm>
#include<memory>//the hearder file of unique_ptr
#include <vector>

using namespace std;

const int INF = 10000;

void insertion(int *A, int n) {//递归版本
    if (n == 0)return;
    insertion(A, n - 1);

    int key = A[n];
    int i = n - 1;
    while (i >= 0 && key < A[i]) {
        A[i + 1] = A[i];i--;
    }
    A[i + 1] = key;
}

void insert_sort(int *A, int A_len) {//下标从0开始
    for (int i = 1;i < A_len;i++) {
        int key = A[i];//即将插入的值
        int j = i - 1;
        while (j >= 0 && key > A[j]) {
            A[j + 1] = A[j];
            j--;
        }
        A[j + 1] = key;
    }
}

void pick_sort(int* A, int A_len) {
    for (int time = 0;time < A_len - 1;time++) {
        int min = A[time], min_index = time;

        for (int i = time + 1;i<A_len;i++)
            if (A[i] < min) { min = A[i];min_index = i; }
        swap(A[min_index], A[time]);
    }
}

void merge(int* A, int p, int q, int r) {
    unique_ptr<int[]> p1(new int[q - p]);//在此使用allocator可减少new调用构造函数的开销
    unique_ptr<int[]> p2(new int[r - q]);

    for (int i = p;i < q;i++)p1[i - p] = A[i];//p1下标从0开始，p2同理，卡了好久大兄弟
    for (int i = q;i < r;i++)p2[i - q] = A[i];

    int i1 = 0, i2 = 0;
    int i;
    for (i = p;i < r;i++) {
        if (i1 == q - p || i2 == r - q)break;

        if (p1[i1] < p2[i2])A[i] = p1[i1++];
        else A[i] = p2[i2++];
    }
    while (i2 != r - q&&i != r)A[i++] = p2[i2++];
    while (i1 != q - p&&i != r)A[i++] = p1[i1++];

}

void merge_sort(int* A, int p, int r) {//左闭右开
    if (r - p == 1)return;//递归程序必有出口
    int q = (p + r) / 2;

    merge_sort(A, p, q);
    merge_sort(A, q, r);
    merge(A, p, q, r);
}

int max_sum(int* A, int low, int high) {
    if (high - low == 1)return A[low];

    int mid = (low + high) / 2;
    int left = max_sum(A, low, mid);
    int right = max_sum(A, mid, high);

    int lpartmax = -INF, lpartsum = 0;
    int i = mid - 1;
    while (i >= low) {
        lpartsum += A[i];
        if (lpartmax < lpartsum)lpartmax = lpartsum;
        i--;
    }

    int rpartmax = -INF, rpartsum = 0;
    i = mid;
    while (i < high) {
        rpartsum += A[i];
        if (rpartmax < rpartsum)rpartmax = rpartsum;
        i++;
    }

    int cross_sum = rpartmax + lpartmax;
    int tmp = max(cross_sum, left);
    tmp = max(tmp, right);
    return tmp;
}

int max_sum(int *A, int A_len) {
    int max = A[0], cur_sum = A[0];
    int i = 1;
    while (i < A_len) {
        if (cur_sum < 0)cur_sum = A[i];
        else cur_sum += A[i];//有点滚动数组的味道,省去一个pre_sum

        if (cur_sum > max)max = cur_sum;

        i++;
    }
    return max;
}

int clumsy_test(int *A, int low, int high) {//最大连续子数组和的暴力版本，可改进为O(N^2)
    int max = -INF;
    for (int i = low;i<high;i++)
        for (int j = low + 1;j <= high;j++)//左闭右开
        {
            int sum = 0;
            for (int k = i;k < j;k++)
                sum += A[k];
            if (sum > max)max = sum;
        }
    return max;
}

上面是基础部分的几个排序算法，当练练手，概率和随机算法看不太下去，以后再来（嘻