快速排序

快速排序源代码：

#include<stdio.h>
#define MAX_LENGTH_INSERT_SORT 7

 void  swap(int k[], int low,int high)		//交换函数
 {
	int temp;
	temp = k[low];
	k[low] = k[high];
	k[high] = temp;
 }
 
  //交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在的位置
 int Partition(int k[],int low,int high)
 {

	int point;
	point = k[low];        //用子表的第一个记录作为枢轴记录
	
	while(low<high)
	{
		while(low<high &&k[high] >= point)
		{
			high--;
		}
		
		swap(k,low,high);  //将比枢轴记录小的记录交换到低端
		
		while(low<high &&k[low] <= point )
		{
			low++;         
		}
		
		swap(k,low,high);  //将比枢轴记录大的记录交换到高端
	}
	return low;
 }
 void QSort(int k[],int low,int high)
 {
	int point;
	
	if(low<high)
		{
			point = Partition(k,low,high);//将数组一分为二
			
			QSort(k,low,point-1);    //对低子表递归排序
			QSort(k,point+1,high); //对高子表递归排序
			
		}
 }
 
 void QuickSort(int k[],int n)
 {
	QSort(k,0,n-1);
 }
 int main(){
 
	int i,a[10] = {5,2,6,0,3,9,1,7,4,8};	
	
	QuickSort(a,10);
	
	 printf("排序后的结果是：");
	 
	 for(i = 0;i < 10;i++)
	 {
		printf("%d",a[i]);
	 }
	 return 0;
 }

快速排序的基本思想是：通过一趟排序将待排序记录分割成独立的两部分，其中

一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继

续进行排序，以达到整个序列有序的目的。

时间复杂度: 最优情况为O(nlogn),最坏情况为O(n²),平均情况是:O(nlogn)

空间复杂度:最好情况为O(logn),最坏情况为O(n),平均情况：O(logn)

优化方式有四种：

a、优化选取枢轴（三数取中法）

b、优化不必要的交换

c、优化小数组时的排序方案（直接插入排序）

d、优化递归操作（采用迭代而不是递归的方法可以缩减堆栈深度，从而提高整体的性能）

经过四种优化方式之后的源码为：

#include<stdio.h>
#define MAX_LENGTH_INSERT_SORT 7

void InsertSort(int k[],int n)
 {
	int i,j,temp;
	
	for(i=1;i<n;i++)
	{
		if(k[i] < k[i-1])
		{	temp = k[i];
			for(j = i-1;k[j]>temp;j--)
			{
				k[j+1] = k[j];
			}
			k[j+1] = temp;
		}
	}
 }
 void InsertSort(int k[],int low,int high)
 {
	InsertSort(k+low,high-low+1);
 }
 
 
 void  swap(int k[], int low,int high)		//交换函数
 {
	int temp;
	temp = k[low];
	k[low] = k[high];
	k[high] = temp;
 }
 
  //交换顺序表L中子表的记录，使枢轴记录到位，并返回其所在的位置
 int Partition(int k[],int low,int high)
 {
	/*
	优化方式一：三数取中法
	*/
	int m = low + (high-low)/2;
	
	if(k[low]>k[high])
		swap(k,low,high);
		
	if(k[m] > k[high])
		swap(k,m,high);
		
	if(k[m]>k[low])
		swap(k,m,low);
	//增加了上面这一段
	int point;
	
	
	point = k[low];        //用子表的第一个记录作为枢轴记录
	
	while(low<high)
	{
		while(low<high &&k[high] >= point)
		{
			high--;
		}
		k[low] = k[high];
		//swap(k,low,high);  //将比枢轴记录小的记录交换到低端
		
		while(low<high &&k[low] <= point )
		{
			low++;         
		}
		k[high] = k[low];
		//swap(k,low,high);  //将比枢轴记录大的记录交换到高端
	}
	k[low] = point;
	return low;
 }
 void QSort(int k[],int low,int high)
 {
	int point;
	
	if(high-low > MAX_LENGTH_INSERT_SORT)
	{
		while(low<high)
		{
			point = Partition(k,low,high);//将数组一分为二
			
			if(point-low<high-point)
				{
				<span style="white-space:pre">	</span>QSort(k,low,point-1);           <span style="white-space:pre">					</span>//对低子表递归排序
					low = point+1;
				}
			else
			{
			      QSort(k,point+1,high); //对高子表递归排序
				high = point-1;
			}
			
		}
	}
	else 
	{
		InsertSort(k,low,high);
	}
 }
 
 void QuickSort(int k[],int n)
 {
	QSort(k,0,n-1);
 }
 int main(){
 
	int i,a[10] = {5,2,6,0,3,9,1,7,4,8};	
	
	QuickSort(a,10);
	
	 printf("排序后的结果是：");
	 
	 for(i = 0;i < 10;i++)
	 {
		printf("%d",a[i]);
	 }
	 return 0;
 }