快速排序

快速排序是对冒泡排序的一种改进，基本思想是：找一个数作为基准，经过一趟排序，将整个序列分成两部分，将比基准数小的数放在它左边，比它大的数放在它右边。如下例：

对这个数组arr进行快速排序，首先我将选取0号下标的数6位基准数，放在临时变量tmp中存储，然后从right下标的数开始比较，如果arr[right]的值大于tmp的值，就一直做right--操作，直到遇到小于tmp的数，然后将此时arr[right]的值放到arr[left]的位置。然后left+1，继续比较arr[left]和tmp的值，如果arr[left]的值小于tmp的值，就做left++操作，如果arr[left]的值大于tmp的值，就将arr[left]放到arr[right]的位置。一直持续次操作，直到left和right相等，就完成了第一趟排序，第一趟排序后的结果为：“2,4,1,6,9,10,8”。

经过第一趟排序后，就以6位基准，将整个数组分成了两部分，6的左边都是比它大的数，右边都是比它小的数，然后又分别对这两部分进行排序，还是采用上述方法。直到最后序列为空或只有一个元素不可分割为止。

使用递归方法的代码实现如下：

# include<iostream>
# include<vector>
# include<iterator>
#  include<string>
using namespace std;

# include<stdio.h>
 
int partition(int arr[],int left,int right)  //一次分割操作
{
	if(left > right)
	{
		return 0;
	}
	int tmp=arr[left];
	while(left < right)
	{
		while(left<right && arr[right] >= tmp)
		{
			right--;
		}
		arr[left]=arr[right];
		while(left<right && arr[left] <= tmp)
		{
			left++;
		}
		arr[right]=arr[left];
	}
	arr[left]=tmp;
	return left;
}
 
void QuickSort(int arr[],int left,int right)  //递归法实现快速排序
{
	int mid=partition(arr,left,right);
	if(left < right)
	{
		QuickSort(arr,left,mid-1);
		QuickSort(arr,mid+1,right);
	}
}
 
void Show(int arr[],int len)  //打印
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}
 
int main()
{
	int arr[]={6,8,1,9,4,10,2,46,91,10,34,98,100,77};
	int len=sizeof(arr)/sizeof(arr[0]);
	QuickSort(arr,0,len-1);
	Show(arr,len);
	return 0;
}

非递归的方式完整代码：

# include<iostream>
# include<stack>
using namespace std;

int partition(int arr[],int left,int right)  //一次分割操作
{
	if(left > right)
	{
		return 0;
	}
	int tmp=arr[left];
	while(left < right)
	{
		while(left<right && arr[right] >= tmp)
		{
			right--;
		}
		arr[left]=arr[right];
		while(left<right && arr[left] <= tmp)
		{
			left++;
		}
		arr[right]=arr[left];
	}
	arr[left]=tmp;
	return left;
}

void Quick(int arr[],int left,int right)//用栈保存每一个待排序子串的首尾元素的下标
{
	stack<int> s;
	int pos=0;
	s.push(left);
	s.push(right);
	while(!s.empty())
	{
		right=s.top();
		s.pop();
		left=s.top();
		s.pop();
		pos=partition(arr,left,right);
		if(pos+1 < right)//先将基准右边的入栈，如果基准右边只有一个元素的时候，就不用入栈了
		{
			s.push(pos+1);
			s.push(right);
		}
		if(pos-1 > left)//再将基准左边的入栈，如果基准左边的只有一个元素的时候，就不用入栈了
		{
			s.push(left);
			s.push(pos-1);
		}
	}
}

void QuickSort(int arr[],int len)
{
	Quick(arr,0,len-1);
}

void Show(int arr[],int len)  //打印
{
	for(int i=0;i<len;i++)
	{
		printf("%d ",arr[i]);
	}
}

int main()
{
	int arr[]={6,8,1,9,4,10,2};
	int len=sizeof(arr)/sizeof(arr[0]);
	QuickSort(arr,len);
	Show(arr,len);
	return 0;
}

快速排序的优化：

（1）三数取中法，解决数据基本有序的（就是找到数组中最小下标，最大下标，中间下标的数字，进行比较，把中间大的数组放在最左边）。

实现代码：

void Swap(int arr[], int first, int second)//交换函数
{
	int tmp = arr[first];
	arr[first] = arr[second];
	arr[second] = tmp;
}
int GetMiddleNumber(int arr[], int left,int right)
{
	int mid=0;
	if(left < right)
	{
		mid = left+(right-left)/2;
	}
	else
	{
		return arr[left];
	}
	if (arr[mid] > arr[right])
	{
		Swap(arr, mid, right);
	}
	if (arr[mid] > arr[left])
	{
		Swap(arr, mid, left);
	}
	if (arr[left] > arr[right])
	{
		Swap(arr, left, right);
	}
	return arr[left];
}

（2）随机选取基准

基本思想：选取待排序列中任意一个元素作为基准。

void Swap(int arr[], int first, int second)//交换函数
{
	int tmp = arr[first];
	arr[first] = arr[second];
	arr[second] = tmp;
}

/*随机选择枢轴的位置，区间在low和high之间*/  
int SelectPivotRandom(int arr[],int low,int high)  
{  
  //产生枢轴的位置  
   srand((unsigned)time(NULL));  
  int pivotPos = rand()%(high - low) + low;   
  //把枢轴位置的元素和low位置元素互换，此时可以和普通的快排一样调用划分函数  
  swap(arr[pivotPos],arr[low]);  
   return arr[low];  
}  

（3）对于很小和部分有序的数组，快排不如插排好。当待排序序列的长度分割到一定大小后，继续分割的效率比插入排序要差，此时可以使用插排而不是快排。

截止范围：待排序序列长度N = 10，虽然在5~20之间任一截止范围都有可能产生类似的结果，这种做法也避免了一些有害的退化情形。

# define N 10
int partition(int arr[],int left,int right)  //一次分割操作
{
	if(left > right)
	{
		return 0;
	}
	int tmp=arr[left];
	while(left < right)
	{
		while(left<right && arr[right] >= tmp)
		{
			right--;
		}
		arr[left]=arr[right];
		while(left<right && arr[left] <= tmp)
		{
			left++;
		}
		arr[right]=arr[left];
	}
	arr[left]=tmp;
	return left;
}

void InsertSort(int arr[], int start, int end)
{
	int tmp = arr[start];
	for (int i = start+1; i <= end; ++i)
	{
		tmp = arr[i];
		int j = i - 1;
		while (j >= start && arr[j] > tmp)
		{
			arr[j + 1] = arr[j];
			--j;
		}
		arr[j + 1] = tmp;
	} 
}

void quick(int *arr,int left,int right)
{
	int length=right-left;
	if(length > N)
	{
		int pivot=partition(arr,left,right);
		quick(arr,left,pivot-1);
		quick(arr,pivot+1,right);
	}
	else
	{
		InsertSort(arr,left,right);
	}
}

（4）在一次排序后，可以将与基准值相等的数放在一起，在下次分割时可以不考虑这些数。能减少迭代次数，效率会提高不少。

比如：

待排序序列： 1 4 6 7 6 6 7 6 8 6

三数取中选取枢轴：下标为4的数6

转换后，待分割序列：6 4 6 7 1 6 7 6 8 6

枢轴tmp：6

本次划分后，未对与tmp元素相等处理的结果：1 4 6 6 7 6 7 6 8 6

下次的两个子序列为：1 4 6 和 7 6 7 6 8 6

本次划分后，对与tmp元素相等处理的结果：1 4 6 6 6 6 6 7 8 7

下次的两个子序列为：1 4 和 7 8 7

void Swap(int arr[], int first, int second)//交换函数
{
	int tmp = arr[first];
	arr[first] = arr[second];
	arr[second] = tmp;
}

void QSort(int arr[],int low,int high)  
{  
    int first = low;  
   int last = high;  
  
   int left = low;  
    int right = high;  
 
   int leftLen = 0;  //用来统计左边与key相等的元素的个数
   int rightLen = 0;  //统计右边与key相等的元素的个数
  
    if (high - low + 1 < 10)  
    {  
        InsertSort(arr,low,high);  //数据量少，就用插入排序
        return;  
    }  
      
    //一次分割  
   int key = SelectPivotMedianOfThree(arr,low,high);//使用三数取中法选择枢轴  
         
    while(low < high)  
    {  
       while(high > low && arr[high] >= key)  
        {  
         if (arr[high] == key)//处理相等元素  
           {  
               swap(arr[right],arr[high]); //把右边与key元素相等的聚集的右端
                right--;  
                rightLen++;  
            }  
            high--;  
        }  
        arr[low] = arr[high];  
        while(high > low && arr[low] <= key)  
       {  
            if (arr[low] == key)  //把左边与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]);  //此时，把数组左端与key相等的数据换到key的左边
        i--;  
        j++;  
    }  
    i = low + 1;  //轴的右边
    j = last;  
    while(j > right && arr[i] != key)  
    {  
       swap(arr[i],arr[j]);  //此时，把数组右端与key相等的数据换到，key右边
       i++;  
       j--;  
   }  
    partition(arr,first,low - 1 - leftLen);  
    partition(arr,low + 1 + rightLen,last);  
}