#include<iostream>
#include<stdlib.h>
#include<time.h>
#include<chrono>
#include<string>
using namespace std;
const int MAX_NUM = 1000;
//没有任何基于比较的算法能够保证使用少于log(N!)~NlogN次比较将长度为N的数组排序
//选择排序与输入无关，不管输入是否有序，时间一致
//选择排序数据移动是最少的，交换次数与数组大小呈线性关系
void SelectSort(int *a, int n) {
    for (int i = 0;i < n;i++) {
        int min = i;
        for (int j = i + 1;j < n;j++) {
            if (a[j] < a[min]) {
                min = j;
            }
        }
        int tmp = a[min];
        a[min] = a[i];
        a[i] = tmp;
    }
}
//插入排序对部分有序的数组十分高效，也适合小规模数组
void InsertSort(int *a, int n) {
    for (int i = 1;i < n;i++) {
        for (int j = i;a[j] < a[j - 1] && j >= 0;j--) {
            int temp = a[j];
            a[j] = a[j - 1];
            a[j - 1] = temp;
        }
    }
}

//插入排序时，元素只能一点点从数组一段移动到另一端，希尔排序交换不相邻的元素以对数组进行排序,加快速度
//对于中等大小的数组，它的运行时间是合适的，且不需要额外的内存。不到平方级别，约莫N的1.5次方。
void HillSort(int *a, int n) {
    int h = 1;
    while (h < n / 3) {
        h = 3 * h + 1;
    }
    while (h >= 1) {
    //  cout << "h is :" << h << endl;
//      cout << "a[h] is: "<<a[h] << endl;
        for (int i = h;i < n;i++) {
            for (int j = i;j >= h && a[j] < a[j - h];j -= h) {
                int temp = a[j];
                a[j] = a[j - h];
                a[j - h] = temp;
            }
        }
        h = h / 3;
    }
}
//归并排序。时间与NLogN成正比，所需的额外空间与N成正比
void merge(int *a, int *b, int lo, int mid, int hi) {
    int i = lo, j = mid + 1;
    for (int k = lo;k <= hi;k++) {
        b[k] = a[k];
    }
    for (int k = lo;k <= hi;k++) {
        if (i > mid)a[k] = b[j++];
        else if (j > hi)a[k] = b[i++];
        else if (b[i] < b[j])a[k] = b[i++];
        else a[k] = b[j++];
    }
}
void mergeSort(int *a, int low, int hi, int *b) {
    if (low >= hi)return;
    int mid = (low + hi) / 2;
    mergeSort(a, low, mid, b);
    mergeSort(a, mid + 1, hi, b);
    merge(a, b, low, mid, hi);
}
void MergeSort(int *a, int n) {
    int *b = new int[n];
    mergeSort(a, 0, n - 1, b);
}
//快速排序只需要一个很小的辅助栈，时间是NlogN成正比
int partition(int *a, int st, int end) {
    int k = a[end];
    int i = st, j = end - 1;
    while (i < j) {
        while (a[i] <= k && i <= j) {
   
   //Here is for other number both small than the last one.
            i++;
        }
        while (a[j] > k &&i < j) {
            j--;
        }
        if (i < j) {
            int tmp = a[i];
            a[i] = a[j];
            a[j] = tmp;
        }
    }
    if (k < a[i]) {
        a[end] = a[i];
        a[i] = k;
    }
    return i;
}
void quickSort(int *a, int st, int end) {
    if (st >= end)return;
    int k = partition(a, st, end);
    quickSort(a, st, k - 1);
    quickSort(a, k + 1, end);
}
void QuickSort(int *a, int n) {
    quickSort(a, 0, n - 1);
}
//堆排序可以用来实现优先队列，如果前K最大或者前K最小。~2NlogN
void adjustHeap(int *a, int n, int node) {
    while (node < n / 2) {
        int child = 2 * node + 1;
        if (child + 1 < n &&a[child] <= a[child + 1]) {
            child += 1;
        }
        if (a[node] < a[child]) {
            int k = a[child];
            a[child] = a[node];
            a[node] = k;
        }
        else {
            break;
        }
        node = child;
    }
}
void makeHeapSort(int *a, int n) {
    for (int i = n / 2;i >= 0;i--) {
        adjustHeap(a, n, i);
    }
}
void HeapSort(int *a, int n) {
    makeHeapSort(a, n);
    for (int i = n - 1;i > 0;i--) {
        int tmp = a[0];
        a[0] = a[i];
        a[i] = tmp;
        adjustHeap(a, i, 0);
    }
}
bool isSort(int *a,int n) {
    for (int i = 0;i < n - 1;i++) {
        if (a[i] > a[i + 1]) {
            cout << "No sort" << endl;
            return false;
        }
    }
    return true;
}
void produceData(int *a) {
    int *b = new int[MAX_NUM];
    for (int i = 0;i < MAX_NUM;i++) {
        b[i] = i;
    }
    int l = MAX_NUM;
    int cu = 0;
    int tmp = 0;
    for (int i = 0;i < MAX_NUM;i++) {   
        cu = rand() % l;
        a[i] = b[cu];
        tmp = b[l - 1];
        b[l - 1] = b[cu];
        b[cu] = tmp;        
        l--;
    }
}
void copyArray(int *a,int *b) {
    for (int i = 0;i < MAX_NUM;i++) {
        b[i] = a[i];
    }
}
void prinArray(int *a,int n) {
    for (int i = 0;i < n;i++) {
        cout << a[i] << " ";
    }
    cout << endl;
}

void staticTime(int *a,string desc, void(*func)(int *, int)) {
    int *b = new int[MAX_NUM];
    copyArray(a, b);
    chrono::milliseconds start = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch());
    func(b, MAX_NUM);
    chrono::milliseconds end = chrono::duration_cast<chrono::milliseconds>(chrono::system_clock::now().time_since_epoch());
    cout << desc << " time is :" << end.count() - start.count() << endl;
    isSort(b, MAX_NUM);
}
void BinarySearch(int *a, int n,int k) {
    int lo = 0, hi = n - 1;
    int mid = 0;
    while (lo<=hi) {
        mid = lo + (hi - lo) / 2;
        if (k < a[mid]) {
            hi = mid - 1;
        }
        else if (k > a[mid]) {
            lo = mid + 1;
        }
        else {
            lo = mid;
            break;
        }
    }
    cout << "Find value k in " << lo << endl;
    cout << k << endl;
}
int main() {
    srand(time(NULL));
    int *a = new int[MAX_NUM];
    produceData(a);
//  staticTime(a, "HillSort", HillSort);
    //staticTime(a, "MergerSort", MergeSort);
//  staticTime(a, "InsertSort", InsertSort);
    //staticTime(a, "QuickSort", QuickSort);
    //staticTime(a, "HeapSort", HeapSort);
    staticTime(a, "SelectSort", SelectSort);
    //prinArray(b, MAX_NUM);
    //prinArray(a, MAX_NUM);
    BinarySearch(a, MAX_NUM, a[0]);
}