#include<iostream>
#include<vector>
using namespace std;void swap(int &p, int &q){int temp;temp = p;p = q;q = temp;
}int  partition(vector<int>&array, int lo, int hi){swap(array[lo], array[lo + rand() % (hi - lo + 1)]);//产生[lo,hi]之间的一个随机数int pivot = array[lo];while (lo < hi){//swapwhile ((lo < hi) && pivot <= array[hi]){hi--;}//array[lo] = array[hi];
        swap(array[lo], array[hi]);while ((lo < hi) && pivot >= array[lo]){lo++;}//array[hi] = array[lo];
        swap(array[lo], array[hi]);}//array[lo] = pivot;return lo;
}
void quicksort(vector<int>&array, int lo, int hi){if (hi - lo < 1)return;int mi = partition(array, lo, hi);quicksort(array, lo, mi-1);quicksort(array, mi + 1, hi);}

int partition(vector<int>&array, int lo, int hi){int pivot = array[lo];while (lo < hi){while (lo < hi&&pivot <= array[hi])hi--;swap(array[lo], array[hi]);while (lo < hi&&pivot >= array[lo])lo++;swap(array[lo], array[hi]);}return lo;
}/**使用栈的非递归快速排序**/
void quicksort2(vector<int> &vec, int low, int high){stack<int> st;if (low<high){int mid = partition(vec, low, high);if (low<mid - 1){st.push(low);st.push(mid - 1);}if (mid + 1<high){st.push(mid + 1);st.push(high);}//其实就是用栈保存每一个待排序子串的首尾元素下标，下一次while循环时取出这个范围，对这段子序列进行partition操作while (!st.empty()){int q = st.top();st.pop();int p = st.top();st.pop();mid = partition(vec, p, q);if (p<mid - 1){st.push(p);st.push(mid - 1);}if (mid + 1<q){st.push(mid + 1);st.push(q);}}}
}

void merge(vector<int>&input, int left, int right, int mid, vector<int>&temp){int i = left;int j = mid+1;int t = 0;while (i<=mid&&j<=right){if (input[i] <= input[j]){temp[t++] = input[i++];}else{temp[t++] = input[j++];}}while (i <= mid){temp[t++] = input[i++];}while (j <= right){temp[t++] = input[j++];}t = 0;while (left <= right){input[left++] = temp[t++];}
}void mergesort(vector<int>&input, int left, int right, vector<int>&temp){if (left < right){int mid = (left + right) / 2;mergesort(input, left, mid, temp);mergesort(input, mid + 1, right, temp);merge(input, left, right, mid, temp);}
}

/* * (最大)堆的向下调整算法** 注：数组实现的堆中，第N个节点的左孩子的索引值是(2N+1)，右孩子的索引是(2N+2)。数组是按层编号的。*     其中，N为数组下标索引值，如数组中第1个数对应的N为0。** 参数说明：*     a -- 待排序的数组*     start -- 被下调节点的起始位置(一般为0，表示从第1个开始)*     end   -- 截至范围(一般为数组中最后一个元素的索引)*/
void maxheap_down(int a[], int start, int end)
{int c = start;            // 当前(current)节点的位置int l = 2*c + 1;        // 左(left)孩子的位置int tmp = a[c];            // 当前(current)节点的大小for (; l <= end; c=l,l=2*l+1){// "l"是左孩子，"l+1"是右孩子if ( l < end && a[l] < a[l+1])l++;        // 左右两孩子中选择较大者，即m_heap[l+1]if (tmp >= a[l])break;        // 调整结束else            // 交换值
        {a[c] = a[l];a[l]= tmp;}}
}/** 堆排序(从小到大)** 参数说明：*     a -- 待排序的数组*     n -- 数组的长度*/
void heap_sort_asc(int a[], int n)
{int i;// 从(n/2-1) --> 0逐次遍历。遍历之后，得到的数组实际上是一个(最大)二叉堆。从下到上，从左到右遍历父节点调整for (i = n / 2 - 1; i >= 0; i--)maxheap_down(a, i, n-1);// 从最后一个元素开始对序列进行调整，不断的缩小调整的范围直到第一个元素for (i = n - 1; i > 0; i--){// 交换a[0]和a[i]。交换后，a[i]是a[0...i]中最大的。swap(a[0], a[i]);// 调整a[0...i-1]，使得a[0...i-1]仍然是一个最大堆。// 即，保证a[i-1]是a[0...i-1]中的最大值。//下面一条语句start=0是因为第一个父节点改变了值，要重新调整为最大堆maxheap_down(a, 0, i-1);}
}

/ brief /void makeheap_down(vector<int>&array, int start, int end){int c = start;//c是当前要下滤的节点for (int i = 2 * start + 1; i <= end; c = i, i = 2 * i + 1){if (i<end&&array[i] < array[i + 1])i++;//i<end不能漏，不然i=end;i+1超出范围if (array[c] >= array[i])break; else{ swap(array[c], array[i]); }}
}
/*堆排序*/
void maxheap_sort(vector<int>&a, int n){ //第一个for循环构建最大堆，n为向量长度 for (int i = n / 2 - 1; i >= 0; i--) makeheap_down(a, i, n-1); //第二个for循环用来排序 for (int i = n-1; i>0; i--){ swap(a[0], a[i]); makeheap_down(a, 0, i-1);//再次调整为最大堆 ，i不能=0
    }
}

void select_sort(vector<int>&a){for (int i = 0; i < a.size()-1; i++){int min_index = i;for (int j = i+1; j < a.size(); j++){if (a[j] < a[min_index]){min_index = j;}}if (min_index!=i)swap(a[i], a[min_index]);}
}

void bubble_sort(vector<int>&a){for (int i = 0; i < a.size()-1; i++){for (int j = 0; j < a.size()-1-i; j++){if (a[j] > a[j + 1]){//swap(a[j], a[j + 1]);int tmp = a[j];a[j] = a[j + 1];a[j + 1] = tmp;}}}
}

void insert_sort(vector<int>&a){for (int i = 1; i < a.size(); i++){int j = i;while (j>0 && a[j] < a[j - 1]){swap(a[j], a[j - 1]);j--;}}
}

void bucketSort(vector<int>&input,int max){vector<int>bucket(max, 0);//max是要排序数组中的最大值+1for (int i = 0; i < input.size(); i++){bucket[input[i]]++;}for (int i = 0,j=0; i < max; i++){while ((bucket[i]--)> 0){//可以排序重复数字input[j++] = i;}}
}

/** 获取数组a中最大值** 参数说明：*     a -- 数组*     n -- 数组长度*/
int get_max(int a[], int n)
{int i, max;max = a[0];for (i = 1; i < n; i++)if (a[i] > max)max = a[i];return max;
}/** 对数组按照"某个位数"进行排序(桶排序)** 参数说明：*     a -- 数组*     n -- 数组长度*     exp -- 指数。对数组a按照该指数进行排序。** 例如，对于数组a={50, 3, 542, 745, 2014, 154, 63, 616}；*    (01) 当exp=1表示按照"个位"对数组a进行排序*    (02) 当exp=10表示按照"十位"对数组a进行排序*    (03) 当exp=100表示按照"百位"对数组a进行排序*    ...*/
void count_sort(int a[], int n, int exp)
{int output[n];             // 存储"被排序数据"的临时数组int i, buckets[10] = {0};// 将数据出现的次数存储在buckets[]中for (i = 0; i < n; i++)buckets[ (a[i]/exp)%10 ]++;// 更改buckets[i]。目的是让更改后的buckets[i]的值，是该数据在output[]中的位置。for (i = 1; i < 10; i++)buckets[i] += buckets[i - 1];// 将数据存储到临时数组output[]中for (i = n - 1; i >= 0; i--){output[buckets[ (a[i]/exp)%10 ] - 1] = a[i];buckets[ (a[i]/exp)%10 ]--;}// 将排序好的数据赋值给a[]for (i = 0; i < n; i++)a[i] = output[i];
}/** 基数排序** 参数说明：*     a -- 数组*     n -- 数组长度*/
void radix_sort(int a[], int n)
{int exp;    // 指数。当对数组按各位进行排序时，exp=1；按十位进行排序时，exp=10；...int max = get_max(a, n);    // 数组a中的最大值// 从个位开始，对数组a按"指数"进行排序for (exp = 1; max/exp > 0; exp *= 10)count_sort(a, n, exp);
}