交换排序

一.冒泡排序

冒泡排序比较熟悉直接用c语言书写：

#include<stdio.h>
int main()
{
	int i,j,flag;
	double a[10],tmp;
	printf("Input 10 numbles:");
	for(i=0;i<10;i++)
		scanf("%lf",&a[i]);
	
	for(i=1;i<10;i++)
	{
		flag=0;   //假设第i趟排序没有数据交换，给flag赋值为3
		for(j=1;j<10-i;j++)
			if(a[j]>a[j+1])
			{
				tmp=a[j];
				a[j]=a[j+1];
				a[j+1]=tmp;		
				flag=1;				//数据交换，给flag赋值1
			}
			if(0==flag)				//如果flag的值为0，表明第i趟排序没有数据交换
				break;
	}

	for(i=0;i<10;i++)
		printf("%6.1f",a[i]);
	printf("\n");
	return 0;
}

二.快速排序

基本思想是：通过一趟排序将待排记录分割成独立的两部分，其中一部分记录关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

假设待排序的序列为{L.r[s]，L.r[s+1]，……，L.r[t]}，首先任意选取一个记录（常常可选第一个记录L.r[s])作为中轴，然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在他的位置之前，将所有关键字较他大的记录都安排在他的位置之后。

一趟快速排序的具体做法是：附设两个指针low和high ，他们的初值分别为low和high，设中轴记录的关键字为pivotkey,则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和中轴记录交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和中轴记录互相交换，重读这两步直至low=high为止。算法如下：

int Parttion(SqList &L,int low,int high)
{
	//交换顺序表L中字表L.r[low..high]的记录，使中轴记录到位，并返回其所在位置，此时在他之前（后）的记录均不大（小）于他
	pivotkey=L.r[low].key;		//用子表的第一个记录作中轴记录
	while(low<high)				//从表的两端交替地向中间扫描
	{
		while(low<high&&L.r[high].key>=pivotkey)
			--high;
	    L.r[0]=L.r[low]; L.r[low]=L.r[high]; L.r[high]=L.r[0];	//将比中轴记录小的记录交换到低端
		while(low<high&&L.r[low].key<==pivotkey)
			++low;
	    L.r[0]=L.r[low]; L.r[low]=L.r[high]; L.r[high]=L.r[0];	//将比中轴记录大的记录交换到高端
	}
	return low;
}

    具体实现上述算法时，每交换一对记录需进行3次移动。而实际上，在排序过程中对中轴记录的赋值是多余的，因为只有在一趟排序结束时，即low=high的位置才是中轴记录的最后位置。由此可改上述算法，先将中轴记录暂存在L.r[0]的位置上，排序过程中只作r[low]或r[high]的单项移动，直至一趟排序结束后再将中轴记录移至正确位置上。

int Parttion(SqList &L,int low,int high)
{
	//交换顺序表L中子表r[low..high]的记录，中轴记录到位，并返回其所在位置，此时他之前（后）的记录均不大（小）于他
	L.r[0]=L.r[low];		//用子表的第一个记录做中轴记录
	pivotkey=L.r[0].key;	//中轴记录关键字
	while(low<high)	
	{										//从表的两端交替地向中间扫描
		while(low<high&&L.r[high]>=pivotkey)		
			--high;						
		L.r[low]=L.r[high];					//将比中轴记录小的中轴记录移到低端
		while(low<high&&L.r[low]<=pivotkey)
			++low;						
		L.r[high]=L.r[low];					//将比中轴记录大的记录移到高端
	}
	L.r[low]=L.r[0];			//中轴记录到位
	return low;					//返回中轴位置
}

递归形式的快速排序算法：

void QSort(SqList &L,int low,int high)
{
	//对顺序表L中的子序列L.r[low..high]作快速排序
	if(low<high)
	{
		pivotloc=Parttion(L,low,high);	//将L.r[low..high]一分为二
		QSort(L,low,pivotloc-1);		//对低子表递归排序，pivotloc是中轴位置
		QSort(L,pivotkey+1,high);		//对高子表递归排序
	}
}

 void QuickSort(SqList &L)
 {
	 //对顺序表L作快速排序
	 QSort(L,1,L.length);
 }

最后附上完整代码：

#include <iostream>
 
using namespace std;
 
void Qsort(int a[], int low, int high)
{
    if(low >= high)
    {
        return;
    }
    int first = low;
    int last = high;
    int key = a[first];/*用字表的第一个记录作为枢轴*/
 
    while(first < last)
    {
        while(first < last && a[last] >= key)
        {
            --last;
        }
 
        a[first] = a[last];/*将比第一个小的移到低端*/
 
        while(first < last && a[first] <= key)
        {
            ++first;
        }
         
        a[last] = a[first];    
/*将比第一个大的移到高端*/
    }
    a[first] = key;/*枢轴记录到位*/
    Qsort(a, low, first-1);
    Qsort(a, first+1, high);
}
int main()
{
    int a[] = {57, 68, 59, 52, 72, 28, 96, 33, 24};
 
    Qsort(a, 0, sizeof(a) / sizeof(a[0]) - 1);/*这里原文第三个参数要减1否则内存越界*/
 
    for(int i = 0; i < sizeof(a) / sizeof(a[0]); i++)
    {
        cout << a[i] << "";
    }
     
    return 0;
}/*参考数据结构p274(清华大学出版社，严蔚敏)*/

更加详细请参见点击打开链接