交换排序

交换排序基本思想：两两比较待排序记录的关键字，如果发现两个记录的次序相反时即进行交换，直到所有记录都没有反序时为止。

***冒泡排序***
基本思路:通过相邻元素之间的比较和交换，使关键字较小的元素逐渐从底部移向顶部，就像水底下的气泡一样逐渐向上冒泡，所以称为冒泡算法。
步骤:
1.从最后一个开始比较相邻的两个比较。
2.标记交换，直到没有交换。

void BubbleSort(RecType R[],int n){
	int i,j;
	int flag;
	RecType r;
	for(i=0;i<n-1;i++){//最后一个不用比
		flag=0;
		for(j=n-1;j>i;j--){
			if(R[j].key<R[j-1].key){//当i=0时,最后的j>0 ,即j=1;j-1=0，包含i=0，没有遗漏。  
				r=R[j];
				R[j]=R[j-1];
				R[j-1]=r;
				flag=1;
			}
		}//end for
		if(0 == flag) return;
	}
}

***快速排序***
基本思想：记录关键字的比较和记录的交换是从两端向中间进行的，待排序关键字较大的记录一次就能够交换到后面单元中，
而关键字较小的记录一次就能够交换到前面单元中，记录每次移动的距离较远，因此总的比较和移动次数较少，速度较快，故
称快速排序。对于基本有序的数组，排序速度反而比较慢。
步骤:
1.建立基本分区算法。
2.建立快速排序算法。
3.递归调用本算法。

int Partition(RecType R[],int i,int j){//R[]为待排序部分，i为低位索引，j为高位索引
	RecType x=R[i];
	while(i<j){
		//先移动j
		while(i<j && x.key<=R[j].key)
			j--;
		if(i<j){//确保是x.key>R[j].key
			R[i]=R[j];
			i++;//i往高位移动一次
		}
		//比较i
		while(i<j && R[i].key<=x.key){
			i++;
		}
		if(i<j){//R[i].key>x.key
			R[j]=R[i];
			j--;
		}
	
	}//end while

	R[i]=x;
	return i;
}
void QuickSort(RecType R[],int low,int high){

	int p;
	if(low<high){
		p=Partition(R,low,high);
		QuickSort(R,low,p-1);//递归调用自身
		QuickSort(R,p+1,high);
	}
}

完整的代码：

#if !defined(EXCHANGESORT_C)
#define EXCHANGESORT_C

#include<stdio.h>

#define MAXSIZE 100
typedef int KeyType;//关键字类型用来比较
typedef char InfoType;//其他类型的信息
typedef struct{
	KeyType key;//排序用的关键字
	InfoType other;//其他附属信息
}RecType;//记录类型
typedef RecType SeqList[MAXSIZE+1];//+1用来使[0]作为哨兵，但是在实际使用中往往不能使[0]作为哨兵

/*交换排序
基本思想：两两比较待排序记录的关键字，如果发现两个记录的次序相反时即进行交换，直到所有记录都没有反序时为止。
*/
/*
***冒泡排序***
基本思路:通过相邻元素之间的比较和交换，使关键字较小的元素逐渐从底部移向顶部，就像水底下的气泡一样逐渐向上冒泡，所以称为冒泡算法。
步骤:
1.从最后一个开始比较相邻的两个比较。
2.标记交换，直到没有交换。
*/
void BubbleSort(RecType R[],int n){
	int i,j;
	int flag;
	RecType r;
	for(i=0;i<n-1;i++){//最后一个不用比
		flag=0;
		for(j=n-1;j>i;j--){
			if(R[j].key<R[j-1].key){//当i=0时,最后的j>0 ,即j=1;j-1=0，包含i=0，没有遗漏。  
				r=R[j];
				R[j]=R[j-1];
				R[j-1]=r;
				flag=1;
			}
		}//end for
		if(0 == flag) return;
	}
}
void PrintSeqList(RecType SeqList[],int n){
	int i;
	for(i=0;i<n;i++){
		printf("%2d,%c ",SeqList[i].key,SeqList[i].other);
		if(i%10 == 9) 
			printf("\n");
	}
}
void BubbleSortTest(){
	RecType SeqList[]={{5,'A'},{4,'B'},{3,'C'},{2,'D'},{1,'E'},{6,'F'},{7,'G'},{5,'H'},{2,'I'},{8,'J'},
						 {9,'K'},{10,'L'},{11,'M'},{12,'N'},{13,'O'},{14,'P'},{1,'Q'},{2,'R'},{3,'S'},{20,'T'}};
	int n=10;
	int i;
	printf("冒泡排序前：\n");
	PrintSeqList(SeqList,n);

	BubbleSort(SeqList,n);

	printf("\n冒泡排序后：\n");
	PrintSeqList(SeqList,n);
}
/*
***快速排序***
基本思想：记录关键字的比较和记录的交换是从两端向中间进行的，待排序关键字较大的记录一次就能够交换到后面单元中，
而关键字较小的记录一次就能够交换到前面单元中，记录每次移动的距离较远，因此总的比较和移动次数较少，速度较快，故
称快速排序。对于基本有序的数组，排序速度反而比较慢。
步骤:
1.建立基本分区算法。
2.建立快速排序算法。
3.递归调用本算法。
*/
int Partition(RecType R[],int i,int j){//R[]为待排序部分，i为低位索引，j为高位索引
	RecType x=R[i];
	while(i<j){
		//先移动j
		while(i<j && x.key<=R[j].key)
			j--;
		if(i<j){//确保是x.key>R[j].key
			R[i]=R[j];
			i++;//i往高位移动一次
		}
		//比较i
		while(i<j && R[i].key<=x.key){
			i++;
		}
		if(i<j){//R[i].key>x.key
			R[j]=R[i];
			j--;
		}
	
	}//end while

	R[i]=x;
	return i;
}
void QuickSort(RecType R[],int low,int high){

	int p;
	if(low<high){
		p=Partition(R,low,high);
		QuickSort(R,low,p-1);//递归调用自身
		QuickSort(R,p+1,high);
	}
}

void QuickSortTest(){
	RecType SeqList[]={{5,'A'},{4,'B'},{3,'C'},{2,'D'},{1,'E'},{6,'F'},{7,'G'},{5,'H'},{2,'I'},{8,'J'},
						 {9,'K'},{10,'L'},{11,'M'},{12,'N'},{13,'O'},{14,'P'},{1,'Q'},{2,'R'},{3,'S'},{20,'T'}};
	int n=10;
	int i;
	printf("快速排序前：\n");
	PrintSeqList(SeqList,n);

	QuickSort(SeqList,0,n-1);

	printf("\n快速排序后：\n");
	PrintSeqList(SeqList,n);
	printf("\n\n");
}



void main(){
	
	BubbleSortTest();
	printf("\n\n");

	
	QuickSortTest();
}

#endif

运行结果：