排序专题之交换排序

在交换排序这一类中，分为冒泡排序和快速排序，快速排序是建立在

冒泡排序基础上的一个优化，很有意义的一个排序，在各种acm竞赛

以及其他领域中经常被用到；

接下来，我们先看一看冒泡排序。

冒泡排序基本思想：
通过无序区中相邻记录关键字间的比较和位置的交换，
使关键字最小的记录如气泡一般逐渐往上“漂浮”直至“水面”。
整个算法是从最下面的记录开始，对每两个相邻的关键字进行比较，
且使关键字较小的记录换至关键字较大的记录之上，使得经过一趟
冒泡排序后，关键字最小的记录到达最上端，接着，再在剩下的记
录中找关键字次小的记录，并把它换在第二个位置上。依次类推，
一直到所有记录都有序为止。

#include<iostream>
using namespace std;
int main()
{
	int n;
	int s[10];
	while(cin>>n)
	{
		int i,j,k;
		for(i=0;i<n;i++)
		{
			cin>>s[i];
		}
		
		for(i=0;i<n-1;i++)
		{
			bool flag=false;  //设置一个变量，若未发生交换，
							 //那么排序任务已经完成； 
			for(j=n-1;j>i;j--)
			{
				if(s[j]<s[j-1])
				{
					int t=s[j];
					s[j]=s[j-1];
					s[j-1]=t;
					flag=true;
				}
			}
			if(flag==false)
			break;
		}
		for(i=0;i<n;i++)
		{
			cout<<s[i]<<"  ";
		}
		cout<<endl;
	}
	return 0;
}

时间复杂度为 n*n，不过易理解，对那些短小的序列排序还是蛮好的一种方法。

大序列的话就相当耗时了；

接下来重点讲一下快速排序：

基本思想：通过一趟排序，将待排序记录分割成独立的两部分，
其中一部分记录的关键字均比另一部分记录的关键字小，则可分
别对这两部分记录进行排序，以达到整个序列有序
排序过程：对r[s……t]中记录进行一趟快速排序，附设两个指针i和j，
设枢轴记录rp=r[s]，x=rp.key
初始时令i=s,j=t
首先从j所指位置向前搜索第一个关键字小于x的记录，并和rp交换
再从i所指位置起向后搜索，找到第一个关键字大于x的记录，和rp交换
重复上述两步，直至i==j为止
再分别对两个子序列进行快速排序，直到每个子序列只含有一个记录为止

#include<stdio.h>
#include<string.h>
void QuickSort(int a[],int numsize)/*a是整形数组，numsize是元素个数*/
{
	int i=0,j=numsize-1;
	int val=a[0];		/*指定参考值val大小*/
	if(numsize>1)		/*确保数组长度至少为2，否则无需排序*/
	{ 
		while(i<j)			/*循环结束条件*/
		{					/*从后向前搜索比val小的元素，找到后填到a[i]中并跳出循环*/
			for(;j>i;j--)
			if(a[j]<val)
			{
				a[i++]=a[j];
				break;
			}				/*从前往后搜索比val大的元素，找到后填到a[j]中并跳出循环*/
			for(;i<j;i++)
			if(a[i]>val)
			{	
				a[j--]=a[i];
			break;
			}
		}
	a[i]=val;			/*将保存在val中的数放到a[i]中*/
	QuickSort(a,i);		/*递归，对前i个数排序*/
	QuickSort(a+i+1,numsize-i-1);/*对i+2到numsize这numsize-1-i个数排序*/
	}	
}
int main()
{
	int s[5];
	int i;
	for(i=0;i<5;i++)
	scanf("%d",&s[i]);
	QuickSort(s,5);
	for(i=0;i<5;i++)
	printf("%d ",s[i]);
	return 0;
}

另一种写法：：

void QKSort(RecordType r[],int low, int high )
/*对记录数组r[low..high]用快速排序算法进行排序*/
{
   int pos;
   if(low<high)
   {
     pos=QKPass(r, low, high);  /*调用一趟快速排序，将枢轴元素为界划分两个子表*/
     QKSort(r, low, pos-1);     /*对左部子表快速排序*/
     QKSort(r, pos+1, high); /*对右部子表快速排序*/
		
	}
}


int   QKPass(RecordType r[],int left,int right)
{    RecordType x;
     int low,high;
     x= r[left];             /* 选择基准记录*/ 
     low=left;       high=right;
     while ( low<high )
	{ while (low< high && r[high].key>=x.key ) 
	     high--;
	  if ( low <high ) 
	     {   r[low]= r[high];
	         low++;
	     }           /* 找到小于x.key的记录，则进行交换*/
	  while (low<high && r[low].key<x.key  ) 
                   low++; 
	  if (  low<high  )
	    {   r[high]= r[low];
	       high--; 
	    }    /* 找到大于x.key的记录，则交换*/
	}
	r[low]=x;                     /*将基准记录保存到low=high的位置*/
	return low;                     /*返回基准记录的位置*/
} /* QKPass */ 

算法评价
时间复杂度
最好情况（每次总是选到中间值作枢轴）T(n)=O(nlog2n)
最坏情况（每次总是选到最小或最大元素作枢轴）T(n)=O(n2)


空间复杂度：需栈空间以实现递归
最坏情况：S(n)=O(n)
一般情况：S(n)=O(log2n)
稳定性：不稳定

利用STL的写法，注意要加头文件 stdlib.h  或 cstdlib

#include<iostream>
#include<cstdlib>
using namespace std;
int com(const void *a1,const void *a2)
{
	return *(int *)a2-*(int *)a1;
}
int main()
{
	int i,j,n;
	int s[5];
	while(cin>>n)
	{
		for(i=0;i<5;i++)
		{
			cin>>s[i];
		}
		qsort(s,5,sizeof(s[0]),com);
		for(i=0;i<n;i++)
		{
			cout<<s[i];
		}
		cout<<endl;
	}
	return 0;
}