快速排序来袭

习惯了开门见山：

快速排序的思想是通过一趟排序将待排记录分割成独立的两部分，关键字左边的都比其小（大），右边的都比其大（小）。分别对这两部分记录继续进行排序，以达到整个序列有序的目的。

 

 

 

 

至此，low和high重合，则一趟快速排序结束。可以看到在关键字5的左边的记录都比它小，右边的记录都比它大。这里的关键字其实就是选的序列中的第一个数字。

以上操作的代码如下：

int partation(int*arr,int low,int high)
{
	if(NULL == arr || low >= high) return -1;
	int key = arr[low];
    while(low<high)   //不能写等于，否则会进入死循环
	{
		while(low<high && arr[high] > key) high--;
		arr[low] = arr[high];
		
		while(low <high && arr[low] < key) low++;
		arr[high] = arr[low];
		
	}
	arr[low] = key;
	return low;
}

 这是快排的核心代码，接下来就是将其左边记录集合不断进行分割排序，右边记录不断进行分割排序，直到两边的记录都排好序，具体代码如下：

void quickSort(int *arr,int low,int high)
{
	if(NULL == arr) return ;
	if(low < high)
	{
		int index = partation(arr,low,high);
        quickSort(arr,low,index-1);
		quickSort(arr,index+1,high);
	}
}

 对这个编辑器也是无语了，好好的代码上去格式老是东倒西歪的！！！！！

上面的代码是递归的写法，下面是利用栈思想实现的非递归代码：

void quick_sort_loop(int *arr, int low, int high) 
{
	int *stack = (int *)malloc(sizeof(int)* high * 2);
	assert(stack != NULL);
	int top = 0;
	stack[top++] = low;
	stack[top++] = high;

	while (top > 0)
	{
		//压栈操作,出栈操作
		high = stack[--top];
		low = stack[--top];
		if (low < high)
		{
			int base = partation(arr, low, high);
			stack[top++] = low; 
			stack[top++] = base - 1;
			stack[top++] = base + 1;
			stack[top++] = high;
		}
	}
	free(stack);
} 

 分析一下它的时间复杂度：

(1)最好情况，比如上面的情况，每次都基本一分为二，这样第一次是遍历n次，之后都基本平均下去，复杂度为O（n*logn）。

(2)最坏的情况为正序或逆序，这样每次划分只能得到比上次少一个记录的子序列，另一个为空。递归数是斜的。复杂度为O（n*2）。

(3)平均的时间复杂度用数学归纳法可以证明，数量级为：O（n*logn）。

空间复杂度：

主要是递归使用的栈空间，为O（logn），非递归写法为O（2n）。

稳定性：由于其关键字的比较过程中是不断跳跃的，所以不稳定。

下面，我们来优化快速排序，

（1）分析代码发现在选取关键字的时候是固定选取arr[low]的。有人提出用随机选取法，但是还是靠运气，再改进有三数取中法。就是先选三个数（一般选第一个，最后一个，中间那个）然后给三个数排序然后取中间那个数作为关键字。数字如果再庞大的话有人提出用九数取中法，具体思路和三数取中法相似。

（2）优化不必要的交换，其实上面代码中已经做过了，就是最后给arr[low]赋值，减少比较过程中的交换赋值。

（3）对于要排序的记录数非常少的时候其实不必要使用快排，直接用插入排序就好没所以在代码中可以做判断，如果high-low大于某个值（根据实际应用）时使用快排，否则使用直接插入排序。

（4）优化递归操作代码如下：

void quickSort(int *arr,int low,int high)
{
	if(NULL == arr) return ;
	if((high-low)>VALUE)   //大于某个值用快排，否则用直接插入排序
	{
		while(low < high)   //尾递归采用迭代减少栈的开辟，提高效率
	    {
			int index = partation(arr,low,high);
			quickSort(arr,low,index-1);
			low = index+1;   
		}
	}else
		insertSort(arr,low-high);
	
}

讲完快速排序，冒泡排序还需要说吗，快排是对冒泡排序的一种升级，都属于交换排序。只是比较的方式不一样所以交换的方式也不一样。来粗略看下代码：

void main()
{
	int arr[10] = {1,4,5,7,3,8,2,9,6,0};
	int len = sizeof(arr)/sizeof(arr[0]);
	int flag = false;
	for(int i = 0;i<len-1;i++)
	{   flag = false;
		for(int j = 0;j<len-i-1;j++)
		{
			if(arr[j] > arr[j+1])
			{
				int temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
				flag = true;
			}
		}
		if(flag == false) break;
	}
}

最后再吐槽下这个编辑器，怎么能没有C语言呢（C语言不伟大吗），其实我上面贴的代码只能算是C语言，算不上C++。你们懂就好。