实验三、排序

实验三、排序一、目的掌握各种排序方法的基本思想、排序过程、算法实现，能进行时间和空间性能的分析，根据实际问题的特点和要求选择合适的排序方法。

二、要求实现直接排序、冒泡、直接选择、快速、堆、归并排序算法。

比较各种算法的运行速度。

三、程序示例#include"stdio.h"#include"stdlib.h"#define Max 100 //假设文件长度typedef struct{ //定义记录类型int key; //关键字项}RecType;typedef RecType SeqList[Max+1]; //SeqList为顺序表，表中第0个元素作为哨兵int n; //顺序表实际的长度1、直接插入排序的基本思想：每次将一个待排序的记录，按其关键字大小插入到前面已排序好的子文件中的适当位置，直到全部记录插入完成为止。

//==========直接插入排序法======void InsertSort(SeqList R){ //对顺序表R中的记录R[1‥n]按递增序进行插入排序int i,j;for(i=2;i<=n;i++) //依次插入R[2]，……，R[n]if(R[i].key<R[i-1].key){ //若R[i].key大于等于有序区中所有的keys，则R[i]留在原位 R[0]=R[i];j=i-1; //R[0]是R[i]的副本do { //从右向左在有序区R[1‥i-1]中查找R[i] 的位置R[j+1]=R[j]; //将关键字大于R[i].key的记录后移j--;}while(R[0].key<R[j].key); //当R[i].key≥R[j].key 是终止R[j+1]=R[0]; //R[i]插入到正确的位置上}//endif}2、冒泡排序的基本思想：设想被排序的记录数组R[1‥n]垂直排序。

根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上“漂浮”（交换），如此反复进行，直到最后任意两个气泡都是轻者在上，重者在下为止。

//==========冒泡排序=======typedef enum{FALSE,TRUE} Boolean; //FALSE为0，TRUE为1void BubbleSort(SeqList R){ //自下向上扫描对R做冒泡排序int i,j;Boolean exchange; //交换标志for(i=1;i<n;i++) { //最多做n-1趟排序exchange=FALSE; //本趟排序开始前，交换标志应为假for(j=n-1;j>=i;j--) //对当前无序区R[i‥n] 自下向上扫描if(R[j+1].key<R[j].key){ //两两比较，满足条件交换记录R[0]=R[j+1]; //R[0]不是哨兵，仅做暂存单元R[j+1]=R[j];R[j]=R[0];exchange=TRUE; //发生了交换，故将交换标志置为真}if(! exchange) //本趟排序未发生交换，提前终止算法return;}// endfor（为循环）}3、快速排序的基本思想：在待排序的n个记录中任取一个记录（通常取第一个记录），把该记录作为支点（又称基准记录）（pivot），将所有关键字比它小的记录放置在它的位置之前，将所有关键字比它大的记录放置在它的位置之后(称之为一次划分过程)。

之后对所分的两部分分别重复上述过程，直到每部分只有一个记录为止。

//1.========一次划分函数=====int Partition(SeqList R,int i,int j){ // 对R[i‥j]做一次划分，并返回基准记录的位置RecType pivot=R[i]; //用第一个记录作为基准while(i<j) { //从区间两端交替向中间扫描，直到i=jwhile(i<j &&R[j].key>=pivot.key) //基准记录pivot相当与在位置i上j--; //从右向左扫描，查找第一个关键字小于pivot.key的记录R[j]if(i<j) //若找到的R[j].key < pivot.key，则R[i++]=R[j]; //交换R[i]和R[j]，交换后i指针加1while(i<j &&R[i].key<=pivot.key) //基准记录pivot相当与在位置j上i++; //从左向右扫描，查找第一个关键字小于pivot.key的记录R[i]if(i<j) //若找到的R[i].key > pivot.key，则R[j--]=R[i]; //交换R[i]和R[j]，交换后j指针减1}R[i]=pivot; //此时，i=j，基准记录已被最后定位return i; //返回基准记录的位置}//2.=====快速排序===========void QuickSort(SeqList R,int low,int high){ //R[low..high]快速排序int pivotpos; //划分后基准记录的位置if(low<high) { //仅当区间长度大于1时才排序pivotpos=Partition(R,low,high); //对R[low..high]做一次划分，得到基准记录的位置QuickSort(R,low,pivotpos-1); //对左区间递归排序QuickSort(R,pivotpos+1,high); //对右区间递归排序}4、直接选择排序的基本思想：第i趟排序开始时，当前有序区和无序区分别为R[1‥i-1]和R[i‥n]（1≤i≤n-1），该趟排序则是从当前无序区中选择出关键字最小的记录R[k]，将它与无序区的的第一个记录R[i]交换，有序区增加一个记录，使R[1‥i],和R[i+1‥n]分别为新的有序区和新的无序区。

如此反复进行，直到排序完毕。

//======直接选择排序========void SelectSort(SeqList R){int i,j,k;for(i=1;i<n;i++){ //做第i趟排序（1≤i≤n-1）k=i;for(j=i+1;j<=n;j++) //在当前无序区R[i‥n]中选key最小的记录R[k] if(R[j].key<R[k].key)k=j; //k记下目前找到的最小关键字所在的位置if(k!=i) { // //交换R[i]和R[k]R[0]=R[i];R[i]=R[k];R[k]=R[0];} //endif} //endfor}5、堆排序的基本思想：它是一种树型选择排序，特点是：在排序的过程中，将R[1‥n]看成是一个完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系，在当前无序区中选择关键字最大（或最小）的记录。

即：把待排序文件的关键字存放在数组R[1‥n]子中，将R看成是一棵二叉树，每个结点表示一个记录，源文件的第一个记录R[1]作为二叉树的根，以下各记录R[2‥n]依次逐层从左到右排列，构成一棵完全二叉树，任意结点R[i]的左孩子是R[2i]，右孩子是R[2i+1]，双亲是R[i/2]。

对这棵完全二叉树的结点进行调整，使各结点的关键字满足下列条件：R[i].key≤R[2i].key并且R[i].key≤R[2i+1].key 称小堆根或R[i].key≥R[2i].key并且R[i].key≥R[2i+1].key 称大堆根//==========大根堆调整函数=======void Heapify(SeqList R,int low,int high){ // 将R[low..high]调整为大根堆，除R[low]外，其余结点均满足堆性质int large; //large指向调整结点的左、右孩子结点中关键字较大者RecType temp=R[low]; //暂存调整结点for(large=2*low; large<=high;large*=2){ //R[low]是当前调整结点//若large>high,则表示R[low]是叶子，调整结束；否则先令large指向R[low]的左孩子if(large<high && R[large].key<R[large+1].key)large++; //若R[low]的右孩子存在且关键字大于左兄弟，则令large指向它//现在R[large]是调整结点R[low]的左右孩子结点中关键字较大者if(temp.key>=R[large].key) //temp始终对应R[low]break; //当前调整结点不小于其孩子结点的关键字，结束调整R[low]=R[large]; //相当于交换了R[low]和R[large]low=large; //令low指向新的调整结点，相当于temp已筛下到large的位置}R[low]=temp; //将被调整结点放入最终位置上//==========构造大根堆==========void BuildHeap(SeqList R){ //将初始文件R[1..n]构造为堆int i;for(i=n/2;i>0;i--)Heapify(R,i,n); //将R[i..n]调整为大根堆}//==========堆排序===========void HeapSort(SeqList R){ //对R[1..n]进行堆排序，不妨用R[0]做暂存单元int i;BuildHeap(R); //将R[1..n]构造为初始大根堆for(i=n;i>1;i--){ //对当前无序区R[1..i]进行堆排序，共做n-1趟。

R[0]=R[1]; R[1]=R[i];R[i]=R[0]; //将堆顶和堆中最后一个记录交换Heapify(R,1,i-1); //将R[1..i-1]重新调整为堆，仅有R[1]可能违反堆性质。

}}6、二路归并排序的基本思想：假设初始序列n个记录，则可看成是n个有序的子序列，每个子序列的长度为1，然后两两归并，得到[n/2]个长度为2或1的有序子序列；再两两归并，……，如此重复，直到一个长度为n的有序序列为止。

//=====将两个有序的子序列R[low..m]和R[m+1..high]归并成有序的序列R[low..high]== void Merge(SeqList R,int low,int m,int high){int i=low,j=m+1,p=0; //置初始值RecType *R1; //R1为局部量R1=(RecType *)malloc((high-low+1)*sizeof(RecType)); //申请空间while(i<=m && j<=high) //两个子序列非空时取其小者输出到R1[p]上R1[p++]=(R[i].key<=R[j].key)? R[i++]:R[j++];while(i<=m) //若第一个子序列非空，则复制剩余记录到R1R1[p++]=R[i++];while(j<=high) //若第二个子序列非空，则复制剩余记录到R1中R1[p++]=R[j++];for(p=0,i=low;i<=high;p++,i++)R[i]=R1[p]; //归并完成后将结果复制回R[low..high]}//=========对R[1..n]做一趟归并排序========void MergePass(SeqList R,int length){int i;for(i=1;i+2*length-1<=n;i=i+2*length)Merge(R,i,i+length-1,i+2*length-1); //归并长度为length的两个相邻的子序列if(i+length-1<n) //尚有一个子序列，其中后一个长度小于lengthMerge(R,i,i+length-1,n); //归并最后两个子序列//注意：若i≤n且i+length-1≥n时，则剩余一个子序列轮空，无须归并}//========== 自底向上对R[1..n]做二路归并排序===============void MergeSort(SeqList R){int length;for(length=1;length<n;length*=2) //做[lgn]趟排序MergePass(R,length); //有序长度≥n时终止}//==========输入顺序表========void input_int(SeqList R){int i;printf("Please input num(int):");scanf("%d",&n);printf("Plase input %d integer:",n);for(i=1;i<=n;i++)scanf("%d",&R[i].key);}//==========输出顺序表========void output_int(SeqList R){int i;for(i=1;i<=n;i++)printf("%4d",R[i].key);}//==========主函数======void main(){int i;SeqList R;input_int(R);printf("\t******** Select **********\n");printf("\t1: Insert Sort\n");printf("\t2: Bubble Sort\n");printf("\t3: Quick Sort\n");printf("\t4: Straight Selection Sort\n");printf("\t5: Heap Sort\n");printf("\t6: Merge Sort\n");printf("\t7: Exit\n");printf("\t***************************\n");scanf("%d",&i); //输入整数1-7，选择排序方式switch (i){case 1: InsertSort(R); break; //值为1，直接插入排序case 2: BubbleSort(R); break; //值为2，冒泡法排序case 3: QuickSort(R,1,n); break; //值为3，快速排序case 4: SelectSort(R); break; //值为4，直接选择排序case 5: HeapSort(R); break; //值为5，堆排序case 6: MergeSort(R); break; //值为6，归并排序case 7: exit(0); //值为7，结束程序}printf("Sort reult:");output_int(R);}四、实验内容1、分析、理解程序。