/*
 快速排序
 基本思想
   選定每次排序的基準資料 在剩下的位置將小於基準值的資料放在基準值得左邊，大於基準值的資料放到基準值的右邊
   一次劃分之後 如果此基準值的左右兩邊仍存在大於兩個資料  則繼續劃分排序 直至每個數字都有序
  遞迴實現Quick_Sort1(int *arr,int len):快排一次劃分的時間複雜度為O(logn) 最壞就是在有序條件下 時間複雜度為O(n^2)
  整體時間複雜度為O(n*logn)
  非遞迴實現Quick_Sort2(int *arr,int len)

 快排三種實現方式
   第一種就是選取第一個元素或者最後一個元素作為基準 程式碼是Quick_Sort1 和Quick_Sort2
   這樣的壞處是如果所給序列是有許多的  那麼時間複雜度太大 選取的基準點就失去了意義 並不能稱作是基準值了
   第二種隨機取值法
    絕大多數情況下保證了時間複雜度最好情況是O(logn)  但是最壞情況下 假如整個陣列的數字都相等 那麼時間複雜度還是能達到O(n^2)
   第三種 三數取中
   找到low high  mid = low + ((high - low) >> 1);//計算陣列中間的元素的下標    

取這三個下標對應的最小值 保證arr[low]是這三個數之間的第二大值 然後又可以和普通劃分函式一樣

*/

void swap(int *a,int *b)
{
	int tmp  = *a;
	*a = *b;
	*b = tmp;
}

//第一種劃分函式:以第一個數字為基準值進行一次劃分 最後返回基準的下標
int partion(int *arr,int low,int high)
{
	if(arr == NULL )
		return -1;
	int tmp = arr[low];

	while(low < high)
	{
		while((low < high) && arr[high] >= tmp)
		{
			high--;
		}
		if(low == high)//如果遇到比基準值小的 放到low的位置
		{
			break;
		}
		else
		{
			arr[low] = arr[high];
		}

		while((low < high) && arr[low] <=  tmp)
		{
			low++;
		}
		if(low == high)
		{
			break;
		}
		else
		{
			arr[high] = arr[low];
		}
	}
	arr[low] = tmp;
	return low;
}
//第二種劃分函式:隨機選取基準劃分
int part(int *arr,int low,int high)
{
	srand((unsigned)time(NULL));
	//產生隨機位置
    int pivotPos = rand()%(high - low) + low;
	//將此隨機位置的值與low位置的值交換 又可以和普通劃分函式一樣
	swap(arr[pivotPos],arr[low]);

	int tmp = arr[low];

	while(low < high)
	{
		while((low < high) && arr[high] >= tmp )
		{
			high--;
		}
		if(low == high)//如果遇到比基準值小的 放到low的位置
		{
			break;
		}
		else
		{
			arr[low] = arr[high];
		}

		while((low < high) && arr[low] <=  tmp)
		{
			low++;
		}
		if(low == high)
		{
			break;
		}
		else
		{
			arr[high] = arr[low];
		}
	}
	arr[low] = tmp;
	return low;
}
//第三種劃分函式
int Select_Mid(int *arr,int low,int high)
{
	//int mid = low + ((high - low) >> 1);//計算陣列中間的元素的下標  
	int mid = low + ((high - low) >> 1);
    //使用三數取中法選擇樞軸  
    if (arr[mid] > arr[high])//目標: arr[mid] <= arr[high]  
    {  
        swap(arr[mid],arr[high]);  
    }  
    if (arr[low] > arr[high])//目標: arr[low] <= arr[high]  
    {  
        swap(arr[low],arr[high]);  
    }  
    if (arr[mid] > arr[low]) //目標: arr[low] >= arr[mid]  
    {  
        swap(arr[mid],arr[low]);  
    }  
	return arr[low];
}
//三數取中的一次劃分
int part1(int *arr,int low,int high)
{
	
	int tmp = Select_Mid(arr,low,high);

	while(low < high)
	{
		while((low < high) && arr[high] >= tmp )
		{
			high--;
		}
		if(low == high)//如果遇到比基準值小的 放到low的位置
		{
			break;
		}
		else
		{
			arr[low] = arr[high];
		}

		while((low < high) && arr[low] <=  tmp)
		{
			low++;
		}
		if(low == high)
		{
			break;
		}
		else
		{
			arr[high] = arr[low];
		}
	}
	arr[low] = tmp;
	return low;
}
static void Quick(int *arr,int start,int end)
{
	int par = part1(arr,start,end);
	if(par > start + 1)
	{
		Quick(arr,start,par-1);
	}
	if(par < end -1)
	{
		Quick(arr,par+1,end);
	}
}
void Quick_Sort1(int *arr,int len)
{
	if(arr == NULL ||len < 0)
		return;
	for(int i = 0 ;i < len - 1 ;++i)
	{
		Quick(arr,0,len-1);
	}
}
 

快排非遞迴實現

//用棧儲存每一次的一對low和high區間 空間複雜度為O(n*logn)
void Quick_Sort2(int *arr,int len)
{
	if( arr == NULL ||len < 0)
		return ;
	int low = 0;
	int high = len - 1;
	int par =  partion(arr,low,high);
	stack<int> st;
	if(par > low + 1)
	{
		st.push(low);
		st.push(par-1);
	}
	if(par < high - 1)
	{
		st.push(par+1);
		st.push(high);
	}
	while(!st.empty())
	{
		int high = st.top();st.pop();
		int low = st.top();st.pop();
		int par = partion(arr,low,high);
		if(par > low + 1)
		{
			st.push(low);
			st.push(par-1);
	}
	if(par < high - 1)
	{
		st.push(par+1);
		st.push(high);
	}
	}
}
 

/*

快排優化一

在low和high之間的舉例為10以內時，可以選擇直接插入排序 節省時間

*/

//快排優化一 在劃分到適合的長度進行直接插入排序
void insert_sort(int *arr,int low,int high)
{
	if(arr == NULL || low < 0 || high < 0)
		return ;
	int tmp = 0;
	int j;
	for(int i = low+1;i < high; i++)
	{
		tmp = arr[i];
		for(j = i-1;j >= 0;j--)
		{
			if(arr[j] > tmp)
			{
				arr[j+1] = arr[j];
			}
			else
			{
				break;
			}
		}
		arr[j+1] = tmp;
	}
}
static void Quick1(int *arr,int start,int end)
{
	int par = part1(arr,start,end);
	if(end - start + 1 < 10)
	{
			insert_sort(arr,start,end);
	}
	else
	{
		if(par > start + 1)
		{
			Quick(arr,start,par-1);
		}
		if(par < end -1)
		{
			Quick(arr,par+1,end);
		}
	}
}
void Quick_Sort3(int *arr,int len)
{
	if(arr == NULL ||len < 0)
		return;
	for(int i = 0 ;i < len - 1 ;++i)
	{
		Quick(arr,0,len-1);
	}
}

/*

 快排優化二
   在一次劃分之後 將與基準值相等的元素聚集在一起不再進行下一次的劃分操作 可以減少迭代查詢次數
   具體操作將與基準值相等的數放到陣列的兩端 一次劃分完成後 將這些數字挪回基準值得範圍 具體過程如下圖所示

*/

//快排優化二 一次劃分後將基準值調至靠近基準值周圍 與基準值相等的數字不再參加下一次劃分
void QuickSort(int *arr,int low,int high)
{
	int first = low;
    int last = high;

    int left = low;
    int right = high;

    int leftLen = 0;
    int rightLen = 0;


    //一次分割
    int key = Select_Mid(arr,low,high);//使用三數取中法選擇樞軸

    while(low < high)
    {
        while(high > low && arr[high] >= key)
        {
            if (arr[high] == key)//處理相等元素
            {
                swap(&arr[right],&arr[high]);
                right--;
                rightLen++;
            }
            high--;
        }
        arr[low] = arr[high];

        while(high > low && arr[low] <= key)
        {
            if (arr[low] == key)
            {
                swap(&arr[left],&arr[low]);
                left++;
                leftLen++;
            }
            low++;
        }
        arr[high] = arr[low];
    }
    arr[low] = key;

    //一次快排結束
    //把與樞軸key相同的元素移到樞軸最終位置周圍
    int i = low - 1;
    int j = first;
    while(j < left && arr[i] != key)
    {
        swap(&arr[i],&arr[j]);
        i--;
        j++;
    }
    i = low + 1;
    j = last;
    while(j > right && arr[i] != key)
    {
        swap(&arr[i],&arr[j]);
        i++;
        j--;
    }
	//如果左右兩端都還有超過兩個資料 那麼就需要進行劃分排序
	if(low-1 > first+1)
	{
		QuickSort(arr,first,low - 1 - leftLen);
	}
	if(low+1 < last-1)
	{
		QuickSort(arr,low + 1 + rightLen,last);
	}

}