#include <iostream>
#include <vector>
#include <list>
#include <string>
#include <unordered_map>
#include <unordered_set>
using namespace std;

void swap(vector<int>& nums,int i , int j)
{
    int tmp = nums[i];
    nums[i] = nums[j];
    nums[j] = tmp;
}

 
void print(const vector<int>& nums)
{
    for(auto num : nums)
    {
        cout << num << " ";
    }
    cout << endl;
}

vector<int> bubbleSort(const vector<int>& v)
{
    vector<int>nums = v;
    int n = nums.size();
    for(int i = 0; i < n - 1
 
; ++i)
    {
        for(int j = 0; j < n -  1 - i ; ++j)
        {
            if(nums[j] > nums[j + 1])
            {
                swap(nums,j,j + 1);
            }
        }
    }
    return nums;
}

vector<int> selectSort(const vector<int>& v)
{
    vector<int>nums = v;
    
 
int n = nums.size();
    for(int i = 0; i < n - 1; ++i)
    {
        int minIndex = i;
        for(int j = i + 1; j < n; ++j)
        {
            if(nums[minIndex] > nums[j])
            {
                minIndex = j;

            }
        }
        swap(nums,minIndex,i);
    }
    return nums;

}

vector<int>insertSort(const vector<int>& v)
{
    vector<int>nums=v;
    int n = nums.size();
    for(int i = 0; i < n; ++i)
    {
        int tmp = nums[i];
        int j = i;
        while(j > 0 && tmp < nums[j-1])
        {
            nums[j] = nums[j-1];
            --j;
        }
        nums[j] = tmp;
    }
    return nums;
}

vector<int>shellSort(const vector<int>& v)
{
    int n = v.size();
    vector<int>nums=v;
    for(int gap = n / 2; gap > 0; gap /= 2)
    {
        for(int i = gap;i < n; ++i)
        {
            int tmp = nums[i];
            int j = i;
            while(nums[j-gap] > tmp)
            {
                nums[j] = nums[j-gap];
                j-=gap;
            }
            nums[j] = tmp;
        }
    }
    return nums;
}

int partition(vector<int>&nums,int left,int right)
{
    int pivot = nums[right];
    int start = left,end = right - 1;
    while(start <= end)
    {
        if(nums[start] <= pivot)++start;
        else if(nums[end] > pivot)--end;
        else swap(nums,start++,end--);
    }
    swap(nums,start,right);
    return start;
}

void helper(vector<int>&nums,int left,int right)
{
    if(left > right)return;
    int pivot = partition(nums,left,right);
    helper(nums,left,pivot-1);
    helper(nums,pivot+1,right);
}

vector<int> quickSort(const vector<int>& v)
{
    vector<int>nums = v;
    int n = nums.size();
    helper(nums,0,n-1);
    return nums;
}

vector<int>merge(vector<int>&n1,vector<int>&n2)
{
    vector<int>res(n1.size()  + n2.size());
    int i = 0, j = 0, k = 0;
    while(i < n1.size() && j < n2.size())
    {
        if(n1[i] <= n2[j])res[k++]  = n1[i++];
        else res[k++] = n2[j++];
    }
    while(i < n1.size())res[k++] = n1[i++];
    while(j < n2.size())res[k++] = n2[j++];
    return res;
}

vector<int>divide(vector<int>& nums,int left,int right)
{
    if(left >= right)return {nums[left]};
    int mid = left + (right - left) / 2;
    vector<int> leftRes = divide(nums,left,mid);
    vector<int> rightRes = divide(nums,mid+1,right);    
    return merge(leftRes,rightRes);    
}

vector<int> mergeSort(const vector<int>& v)
{
    vector<int>nums=v;
    int n = nums.size();    
    return divide(nums,0,n-1);
}

void heapify(vector<int>& nums,int n, int i)
{
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    if(l < n && nums[l] > nums[largest])
    {
        largest = l;
    }
    if(r < n && nums[r] > nums[largest])
    {
        largest = r;
    }
    if(largest != i)
    {
        swap(nums,i,largest);
        heapify(nums,n,largest);
    }
}

vector<int> heapSort(const vector<int>& v)
{
    vector<int> nums = v;
    int n = nums.size();
    for(int i = n / 2 - 1; i >= 0; --i)
    {
        heapify(nums,n,i);
    }
    for(int i = n - 1; i >= 0; --i)
    {
        swap(nums,i,0);
        heapify(nums,i,0);
    }
    return nums;
}

vector<int>CountSort(const vector<int>& v)
{
    vector<int> nums = v;
    int n = nums.size();
    vector<int>output(n);
    int maxVal = * max_element(nums.begin(),nums.end());
    vector<int>cnt(maxVal,0);
    for(int num:nums)
    {
        ++cnt[num];
    }
    for(int i = 1; i <= maxVal; ++i)
    {
        cnt[i] += cnt[i-1];
    }
    for(int i = n - 1; i >= 0; --i)
    {
        output[cnt[nums[i]] - 1] = nums[i];
        --cnt[nums[i]];
    }
    return output;
}

void CountSort(vector<int>& nums,int n, int exp)
{
    vector<int>output(n,0);
    int i = 0;
    vector<int>cnt(10,0);
    for(int i = 0; i < n; ++i)
    {
        ++cnt[nums[i] / exp % 10];
    }
    for(int i = 1; i < 10; ++i)cnt[i] += cnt[i-1];
    for(int i = n - 1; i >= 0; --i)
    {
        output[cnt[nums[i] / exp % 10] - 1] = nums[i];
        --cnt[nums[i]/exp % 10];
    }    
    nums = output;
}

vector<int>radixSort(const vector<int>& v)
{
    vector<int> nums = v;
    int m = * max_element(nums.begin(),nums.end());    
    int exp = 1;
    while(m / exp > 0)
    {
        CountSort(nums,nums.size(),exp);  
        exp *= 10;             
    }
    return nums;
}


vector<int> bucketSort(const std::vector<int> &nums)
  {
    // 思想：
    // 桶排序是計數排序的一個優化,它解決了計數排序只適用於整數排序的限制,更是解決了不適用於最大值和最小值差值很大的情況.
    // 桶排序的思想就是對最小值和最小值之間的元素進行瓜分,將他們分為多個區間,每個區間用一個桶（其實就是一個容器）來裝.
    // 前一個桶裡的元素全都小於後一個桶裡的元素,只需要利用別的常規排序演算法將桶裡面的元素進行排序使之有序即可使得原序列有序.
    // 這裡我們使用快速排序對桶內的元素進行排序.
    // 1.遍歷待排序序列獲取其中最大值和最小值,並計算他們的差值d.
    vector<int>data = nums;
    int max = data[0];
    int min = data[0];
    for(int i = 1; i < data.size(); i++)
    {
      if(max < data[i])
      {
        max = data[i];
      }
      if(min > data[i])
      {
        min= data[i];
      }
    }
    int d = max - min;
    // 2.初始化桶,桶因為要頻繁插入元素,所以用List資料結構,然後所有的桶放在vector容器中.
    std::vector<std::list<int>> bucket_list;
    // 我們將桶的個數設定為原序列元素個數.
    int bucket_num = data.size();
    bucket_list.resize(bucket_num);
    // 3.遍歷原序列,將元素放到合適的桶中.
    for(int value : data)
    {
      // 定位元素所屬的桶的索引.
      // 桶所有的桶平均劃分最大值和最小值d的區間,value-min是當前元素與最小值的差值(區間).
      // bucket_num-1是總的區間個數,則d/(bucket_num-1)代表一個區間的長度.
      // 那麼整個表示式得到的index則為當前元素value所跨越的區間個數,也就是當前元素所在的桶的索引.
      int index = (value-min)/(d/(bucket_num-1));
      // 將當前元素放進桶裡面去.
      bucket_list.at(index).push_back(value);
    }
    // 4.對每個桶進行排序,我們採用快速排序.
    // 依次將每個桶裡的元素排好序後放入sorted_sequence中.
    std::vector<int> sorted_sequence;
    for(auto bucket : bucket_list)
    {
      // 因為我們之前寫的快排是對vector<int>進行排序,所以我們使用一個輔助容器.
      // 我們完全可以重新寫一個針對list<int>的快排演算法,這樣會提高時間和空間複雜度,此處我們就使用現成的.
      std::vector<int> auxiliary;
      auxiliary.assign(bucket.begin(),bucket.end());
      sort(auxiliary.begin(),auxiliary.end());      
      // 將當前桶內元素排好序後放入sorted_sequence容器尾部.
      sorted_sequence.insert(sorted_sequence.end(),auxiliary.begin(),auxiliary.end());
    }
    // 5.將有序序列賦給data.
    data = sorted_sequence;
    return data;
  }

void divide(vector<int>& nums, int left,int right,int k)
{
    if(left >= right)return ;
    int pivot = partition(nums,left,right);
    if(pivot == nums.size() - k)return;
    else if(pivot < nums.size() - k)divide(nums,pivot + 1,right,k);
    else divide(nums,left,pivot-1,k);    
}

int findKthLargest(const vector<int>& nums,int k)
{
    vector<int>v = nums;
    divide(v,0,v.size() - 1,k);
    return v[v.size()-k];
}

void sortColors(vector<int>& colors)
{
    int cnt0 = 0, cnt1 = 0, cnt2 = 0;
    for(int i = 0; i < colors.size(); ++i)
    {
        if(0 == colors[i]) ++cnt0;
        if(1 == colors[i]) ++cnt1;
        if(2 == colors[i]) ++cnt2;        
    }
    for(int i = 0; i < colors.size(); ++i)
    {
        if(i < cnt0) colors[i] = 0;
        else if(i < cnt0 + cnt1) colors[i] = 1;
        else colors[i] = 2;
    }
    return ;
}

string frequencySort(string s)
{
    unordered_map<char,int>map;
    unordered_set<char>set;
    for(char c: s)
    {
        set.insert(c);
        ++map[c];
    }
    vector<string>bucket(s.size() + 1,"");
    for(char c: set)
    {
        int freq = map[c];
        bucket[freq].push_back(c);
    }
    string res = "";    
    for(int i = bucket.size() - 1; i >= 0; --i)
    {        
        if(bucket[i].size() != 0)
        {                       
            for(char c : bucket[i])
            {
              for(int m = 0; m < i; ++m)
              {                  
                  res.push_back(c);
              }
            }
        }
    }
    return res;
}

int maxGap(vector<int>& nums)
{
    if(nums.size() < 2) return 0;
    int m = *(max_element(nums.begin(),nums.end()));
    int exp = 1;
    int R = 10;
    vector<int>aux(nums.size());
    while(m / exp > 0)
    {
        vector<int>cnt(R);
        for(int i = 0; i < nums.size(); ++i)++cnt[(nums[i]/exp % 10)];
        for(int i = 1; i < cnt.size(); ++i)cnt[i]+=cnt[i-1];
        for(int i = nums.size() - 1;i >= 0; --i)
        {
            aux[--cnt[(nums[i]/exp)%10]]=nums[i];
        }
        for(int i = 0; i < nums.size(); ++i)
        {
            nums[i] = aux[i];
        }
        exp *= 10;
    }
    int res = 0;
    for(int i = 1; i < aux.size(); ++i)
    {
        res = max(res,aux[i] - aux[i-1]);
    }
    return res;
}

vector<int> pancakeSort(vector<int>& arr) {
 vector<int> ret;
 for (int n = arr.size(); n > 1; n--) {
     int index = max_element(arr.begin(), arr.begin() + n) - arr.begin();
     if (index == n - 1) {
        continue;
    }
    reverse(arr.begin(), arr.begin() + index + 1);
    reverse(arr.begin(), arr.begin() + n);
    ret.push_back(index + 1);
    ret.push_back(n);
}
return ret;
}

int main()
{

    //排序
    vector<int>nums{3,345,6,3,3};
    
    print(bubbleSort(nums));
    print(selectSort(nums));
    print(insertSort(nums));
    print(shellSort(nums));
    print(quickSort(nums));    
    print(mergeSort(nums));
    print(heapSort(nums));
    print(CountSort(nums));
    print(radixSort(nums));
    print(bucketSort(nums));


    //LeetCode215
    nums = {3,2,1,5,6,4};
    int k = 2;
    cout << findKthLargest(nums,k) << endl;

    //LeetCode75
    nums = {2,0,2,1,1,0};
    sortColors(nums);
    print(nums);

    //LeetCode451
    string s = "tree";
    cout << frequencySort(s) << endl;

    //LeetCode164
    nums = {3,6,9,1};
    cout << maxGap(nums) << endl;
    
    //LeetCode969
    cout << "====" << endl;
    vector<int>arr{3,2,4,1};
    print(pancakeSort(arr));
    return 0;
}