数据结构实验7排序之交换排序
2017唐班数据结构-17排序
比较次数 记录移动次数
最好 平均 最坏
n1 (n1)(n4)/4 (n1)(n2)/2
2n2 (n1)(n8)/4 (n1)(n4)/2
优点：算法简单. 缺点：期望和最坏复杂度为 O(n2) . 稳定性：稳定 辅助空间： O(1)
希尔排序(shell)
将记录按下标的一定增量分组，对每组使用直 接插入排序算法排序；
最 坏时间复杂度 排序前记录已按关键词逆序排列，即dj j-1. 总的
比较次数为n1 n(n-1)/2，总的移动次数为 2(n1) n(n-1)/2.
期望时间复杂度
考察分析 j 2 n dj 的期望值。
对于序列 K1，K2，…，Kn ，如果 1 i j n，且 Ki Kj，则称（Ki , Kj）为上述序列的一个反序对.
实际上， j 2 n dj 正好是序列 K1，K2，…，Kn
的反序对个数。反序对的平均个数为 0+ (0+1)/2+ (0+1+2)/3+ (0123)/4(01234)/5 (012345)/6 … (012…n1)/n 01/22/2 3/24/25/2…( n1)/2 n(n1)/4
直接插入排序小结
7.6 .
79
90
90
90
90 四
趟
56
79
79
88
88 完 交
90
56
88
79
79
成替 排上
4
88
56
56
56 序 浮
下
32
4
32
35
35
沉
27
32
27
32
32
排 序
数据结构实验报告——排序
1．实验要求【实验目的】学习、实现、对比各种排序算法，掌握各种排序算法的优劣，以及各种算法使用的情况。
【实验内容】使用简单数组实现下面各种排序算法，并进行比较。
排序算法：1、插入排序2、希尔排序3、冒泡排序4、快速排序5、简单选择排序6、堆排序（选作）7、归并排序（选作）8、基数排序（选作）9、其他要求：1、测试数据分成三类：正序、逆序、随机数据2、对于这三类数据，比较上述排序算法中关键字的比较次数和移动次数（其中关键字交换计为3次移动）。
3、对于这三类数据，比较上述排序算法中不同算法的执行时间，精确到微秒（选作）4、对2和3的结果进行分析，验证上述各种算法的时间复杂度编写测试main()函数测试线性表的正确性。
2. 程序分析2.1 存储结构存储结构：数组2.2 关键算法分析//插入排序void InsertSort(int r[], int n) {int count1=0,count2=0;插入到合适位置for (int i=2; i<n; i++){r[0]=r[i]; //设置哨兵for (int j=i-1; r[0]<r[j]; j--) //寻找插入位置r[j+1]=r[j]; //记录后移r[j+1]=r[0];count1++;count2++;}for(int k=1;k<n;k++)cout<<r[k]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//希尔排序void ShellSort(int r[], int n){int i;int d;int j;int count1=0,count2=0;for (d=n/2; d>=1; d=d/2) //以增量为d进行直接插入排序{for (i=d+1; i<n; i++){r[0]=r[i]; //暂存被插入记录for (j=i-d; j>0 && r[0]<r[j]; j=j-d)r[j+d]=r[j]; //记录后移d个位置r[j+d]=r[0];count1++;count2=count2+d;}count1++;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; }//起泡排序void BubbleSort(int r[], int n) {插入到合适位置int temp;int exchange;int bound;int count1=0,count2=0;exchange=n-1; //第一趟起泡排序的范围是r[1]到r[n]while (exchange) //仅当上一趟排序有记录交换才进行本趟排序{bound=exchange;exchange=0;for(int j=0;j<bound;j++) //一趟起泡排序{count1++; //接下来有一次比较if(r[j]>r[j+1]){temp=r[j]; //交换r[j]和r[j+1]r[j]=r[j+1];r[j+1]=temp;exchange=j; //记录每一次发生记录交换的位置count2=count2+3; //移动了3次}}}for(int i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//快速排序一次划分int Partition(int r[], int first, int end,int &count1,int &count2){int i=first; //初始化int j=end;while (i<j){while (i<j && r[i]<= r[j]){j--; //右侧扫描count1++;}count1++;if (i<j){temp=r[i]; //将较小记录交换到前面r[i]=r[j];r[j]=temp;i++;count2=count2+3;}while (i<j && r[i]<= r[j]){i++; //左侧扫描count1++;}count1++;if (i<j){temp=r[j];r[j]=r[i];r[i]=temp; //将较大记录交换到后面j--;count2=count2+3;}}return i; //i为轴值记录的最终位置}//快速排序void QuickSort(int r[], int first, int end,int &count1,int &count2){if (first<end){ //递归结束int pivot=Partition(r, first, end,count1,count2); //一次划分QuickSort(r, first, pivot-1,count1,count2);//递归地对左侧子序列进行快速排序QuickSort(r, pivot+1, end,count1,count2); //递归地对右侧子序列进行快速排序}}//简单选择排序Array void SelectSort(int r[ ], int n){int i;int j;int index;int temp;int count1=0,count2=0;for (i=0; i<n-1; i++) //对n个记录进行n-1趟简单选择排序{index=i;for(j=i+1;j<n;j++) //在无序区中选取最小记录{count1++; //比较次数加一if(r[j]<r[index]) //如果该元素比现在第i个位置的元素小index=j;}count1++; //在判断不满足循环条件j<n时，比较了一次if(index!=i){temp=r[i]; //将无序区的最小记录与第i个位置上的记录交换r[i]=r[index];r[index]=temp;count2=count2+3; //移动次数加3 }}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//筛选法调整堆void Sift(int r[],int k,int m,int &count1,int &count2) //s，t分别为比较和移动次数{int i;int j;int temp;i=k;j=2*i+1; //置i为要筛的结点，j为i的左孩子while(j<=m) //筛选还没有进行到叶子{if(j<m && r[j]<r[j+1]) j++; //比较i的左右孩子，j为较大者count1=count1+2; //该语句之前和之后分别有一次比较if(r[i]>r[j])break; //根结点已经大于左右孩子中的较大者else{temp=r[i];r[i]=r[j];r[j]=temp; //将根结点与结点j交换i=j;j=2*i+1; //下一个被筛结点位于原来结点j的位置count2=count2+3; //移动次数加3 }}}//堆排序void HeapSort(int r[],int n){int count1=0,count2=0; //计数器，计比较和移动次数int i;int temp;for(i=n/2;i>=0;i--) //初始建堆，从最后一个非终端结点至根结点Sift(r,i,n,count1,count2) ;for(i=n-1; i>0; i--) //重复执行移走堆顶及重建堆的操作{temp=r[i]; //将堆顶元素与最后一个元素交换r[i]=r[0];r[0]=temp; //完成一趟排序，输出记录的次序状态Sift(r,0,i-1,count1,count2); //重建堆}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;}//一次归并void Merge(int r[], int r1[], int s, int m, int t){int i=s;int j=m+1;int k=s;while (i<=m && j<=t){if (r[i]<=r[j])r1[k++]=r[i++]; //取r[i]和r[j]中较小者放入r1[k]elser1[k++]=r[j++];}if (i<=m)while (i<=m) //若第一个子序列没处理完，则进行收尾处理r1[k++]=r[i++];elsewhile (j<=t) //若第二个子序列没处理完，则进行收尾处理r1[k++]=r[j++];}//一趟归并void MergePass(int r[ ], int r1[ ], int n, int h){int i=0;int k;while (i<=n-2*h) //待归并记录至少有两个长度为h的子序列{Merge(r, r1, i, i+h-1, i+2*h-1);i+=2*h;}if (i<n-h)Merge(r, r1, i, i+h-1, n); //待归并序列中有一个长度小于h else for (k=i; k<=n; k++) //待归并序列中只剩一个子序列r1[k]=r[k];}//归并排序void MergeSort(int r[ ], int r1[ ], int n ){int h=1;int i;while (h<n){MergePass(r, r1, n-1, h); //归并h=2*h;MergePass(r1, r, n-1, h);h=2*h;}for(i=1;i<n;i++)cout<<r[i]<<" ";cout<<endl;}void Newarray(int a[],int b[],int c[]) {cout<<"新随机数组：";c[0]=0;a[0]=0;b[0]=0;for(int s=1;s<11;s++){a[s]=s;b[s]=20-s;c[s]=rand()%50+1;cout<<c[s]<<" ";}cout<<endl;}2.3 其他3. 程序运行结果void main(){srand(time(NULL));const int num=11; //赋值int a[num];int b[num];int c[num];int c1[num];c[0]=0;a[0]=0;b[0]=0;Newarray(a,b,c);cout<<"顺序数组：";for(int j=1;j<num;j++)cout<<a[j]<<" ";cout<<endl;cout<<"逆序数组：";for(j=1;j<num;j++)cout<<b[j]<<" ";cout<<endl;cout<<endl;cout<<"插入排序结果为："<<"\n";InsertSort(a,num);InsertSort(b,num);InsertSort(c,num);cout<<endl;Newarray(a,b,c);cout<<"希尔排序结果为："<<"\n";ShellSort(a, num);ShellSort(b, num);ShellSort(c, num);cout<<endl;Newarray(a,b,c);cout<<"起泡排序结果为："<<"\n";BubbleSort(a, num);BubbleSort(b, num);BubbleSort(c, num);cout<<endl;int count1=0,count2=0;Newarray(a,b,c);cout<<"快速排序结果为："<<"\n";QuickSort(a,0,num-1,count1,count2);for(int i=1;i<num;i++)cout<<a[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(b,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<b[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl; count1=0,count2=0;QuickSort(c,0,num-1,count1,count2);for(i=1;i<num;i++)cout<<c[i]<<" ";cout<<endl;cout<<"比较次数为"<<count1<<" 移动次数为"<<count2<<endl;cout<<endl;cout<<endl;Newarray(a,b,c);cout << "简单选择排序结果为：" << "\n";SelectSort(a,num);SelectSort(b,num);SelectSort(c,num);cout<<endl;Newarray(a,b,c);cout << "堆排序结果为：" << "\n";HeapSort(a, num);HeapSort(b, num);HeapSort(c, num);cout<<endl;Newarray(a,b,c);cout << "归并排序结果为：" << "\n";MergeSort(a, c1,num );MergeSort(b, c1,num );MergeSort(c, c1,num );}。
数据结构课程设报告—各种排序算法的比较
数据结构课程设计报告几种排序算法的演示1、需求分析:运行环境:Microsoft Visual Studio 20052、程序实现功能:3、通过用户键入的数据, 经过程序进行排序, 最后给予数据由小到大的输出。
排序的方式包含教材中所介绍的几种常用的排序方式：直接插入排序、折半插入排序、冒泡排序、快速排序、选择排序、堆排序、归并排序。
每种排序过程中均显示每一趟排序的细节。
程序的输入:输入所需排序方式的序号。
输入排序的数据的个数。
输入具体的数据元素。
程序的输出:输出排序每一趟的结果, 及最后排序结果1、设计说明:算法设计思想:a交换排序（冒泡排序、快速排序）交换排序的基本思想是: 对排序表中的数据元素按关键字进行两两比较, 如果发生逆序（即排列顺序与排序后的次序正好相反）, 则两者交换位置, 直到所有数据元素都排好序为止。
b插入排序（直接插入排序、折半插入排序）插入排序的基本思想是: 每一次设法把一个数据元素插入到已经排序的部分序列的合适位置, 使得插入后的序列仍然是有序的。
开始时建立一个初始的有序序列, 它只包含一个数据元素。
然后, 从这个初始序列出发不断插入数据元素, 直到最后一个数据元素插到有序序列后, 整个排序工作就完成了。
c选择排序（简单选择排序、堆排序）选择排序的基本思想是: 第一趟在有n个数据元素的排序表中选出关键字最小的数据元素, 然后在剩下的n-1个数据元素中再选出关键字最小（整个数据表中次小）的数据元素, 依次重复, 每一趟（例如第i趟, i=1, …, n-1）总是在当前剩下的n-i+1个待排序数据元素中选出关键字最小的数据元素, 作为有序数据元素序列的第i个数据元素。
等到第n-1趟选择结束, 待排序数据元素仅剩下一个时就不用再选了, 按选出的先后次序所得到的数据元素序列即为有序序列, 排序即告完成。
d归并排序（两路归并排序）1、两路归并排序的基本思想是: 假设初始排序表有n个数据元素, 首先把它看成是长度为1的首尾相接的n个有序子表（以后称它们为归并项）, 先做两两归并, 得n/2上取整个长度为2的归并项（如果n为奇数, 则最后一个归并项的长度为1）；再做两两归并, ……, 如此重复, 最后得到一个长度为n的有序序列。
《数据结构》实验报告——排序
《数据结构》实验报告排序实验题目：输入十个数，从插入排序，快速排序，选择排序三类算法中各选一种编程实现。
实验所使用的数据结构内容及编程思路：1.插入排序：直接插入排序的基本操作是，将一个记录到已排好序的有序表中，从而得到一个新的，记录增一得有序表。
一般情况下，第i趟直接插入排序的操作为：在含有i-1个记录的有序子序列r［1..i-1］中插入一个记录r［i］后，变成含有i个记录的有序子序列r［1..i］；并且，和顺序查找类似，为了在查找插入位置的过程中避免数组下标出界，在r［0］处设置哨兵。
在自i-1起往前搜索的过程中，可以同时后移记录。
整个排序过程为进行n-1趟插入，即：先将序列中的第一个记录看成是一个有序的子序列，然后从第2个记录起逐个进行插入，直至整个序列变成按关键字非递减有序序列为止。
2.快速排序：基本思想是，通过一趟排序将待排记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
假设待排序的序列为{L.r[s]，L.r[s+1],…L.r[t]},首先任意选取一个记录(通常可选第一个记录L.r[s])作为枢轴（或支点）（pivot），然后按下述原则重新排列其余记录：将所有关键字较它小的记录都安置在它的位置之前，将所有关键字较大的记录都安置在它的位置之后。
由此可以该“枢轴”记录最后所罗的位置i作为界线，将序列{L.r[s]，…，L.r[t]}分割成两个子序列{L.r[i+1],L.[i+2],…,L.r[t]}。
这个过程称为一趟快速排序，或一次划分。
一趟快速排序的具体做法是：附设两个指针low和high，他们的初值分别为low和high，设枢轴记录的关键字为pivotkey，则首先从high所指位置起向前搜索找到第一个关键字小于pivotkey的记录和枢轴记录互相交换，然后从low所指位置起向后搜索，找到第一个关键字大于pivotkey的记录和枢轴记录互相交换，重复这两不直至low=high为止。
数据结构(C语言版)实验报告 (内部排序算法比较)
《数据结构与算法》实验报告一、需求分析问题描述：在教科书中，各种内部排序算法的时间复杂度分析结果只给出了算法执行时间的阶，或大概执行时间。
试通过随机数据比较各算法的关键字比较次数和关键字移动次数，以取得直观感受。
基本要求：（l）对以下6种常用的内部排序算法进行比较：起泡排序、直接插入排序、简单选择排序、快速排序、希尔排序、堆排序。
（2）待排序表的表长不小于100000；其中的数据要用伪随机数程序产生；至少要用5组不同的输入数据作比较；比较的指标为有关键字参加的比较次数和关键字的移动次数（关键字交换计为3次移动）。
（3）最后要对结果作简单分析，包括对各组数据得出结果波动大小的解释。
数据测试：二．概要设计1.程序所需的抽象数据类型的定义：typedef int BOOL; //说明BOOL是int的别名typedef struct StudentData { int num; //存放关键字}Data; typedef struct LinkList { int Length; //数组长度Data Record[MAXSIZE]; //用数组存放所有的随机数} LinkList int RandArray[MAXSIZE]; //定义长度为MAXSIZE的随机数组void RandomNum() //随机生成函数void InitLinkList(LinkList* L) //初始化链表BOOL LT(int i, int j,int* CmpNum) //比较i和j 的大小void Display(LinkList* L) //显示输出函数void ShellSort(LinkList* L, int dlta[], int t,int* CmpNum, int* ChgNum) //希尔排序void QuickSort (LinkList* L, int* CmpNum, int* ChgNum) //快速排序void HeapSort (LinkList* L, int* CmpNum, int* ChgNum) //堆排序void BubbleSort(LinkList* L, int* CmpNum, int* ChgNum) //冒泡排序void SelSort(LinkList* L, int* CmpNum, int* ChgNum) //选择排序void Compare(LinkList* L,int* CmpNum, int* ChgNum) //比较所有排序2 .各程序模块之间的层次（调用）关系：二、详细设计typedef int BOOL; //定义标识符关键字BOOL别名为int typedef struct StudentData //记录数据类型{int num; //定义关键字类型}Data; //排序的记录数据类型定义typedef struct LinkList //记录线性表{int Length; //定义表长Data Record[MAXSIZE]; //表长记录最大值}LinkList; //排序的记录线性表类型定义int RandArray[MAXSIZE]; //定义随机数组类型及最大值/******************随机生成函数********************/void RandomNum(){int i; srand((int)time(NULL)); //用伪随机数程序产生伪随机数for(i=0; i小于MAXSIZE; i++) RandArray[i]<=(int)rand(); 返回;}/*****************初始化链表**********************/void InitLinkList(LinkList* L) //初始化链表{int i;memset(L,0,sizeof(LinkList));RandomNum();for(i=0; i小于<MAXSIZE; i++)L->Record[i].num<=RandArray[i]; L->Length<=i;}BOOL LT(int i, int j,int* CmpNum){(*CmpNum)++; 若i<j) 则返回TRUE; 否则返回FALSE;}void Display(LinkList* L){FILE* f; //定义一个文件指针f int i;若打开文件的指令不为空则//通过文件指针f打开文件为条件判断{ //是否应该打开文件输出“can't open file”;exit(0); }for (i=0; i小于L->Length; i++)fprintf(f,"%d\n",L->Record[i].num);通过文件指针f关闭文件;三、调试分析1.调试过程中遇到的问题及经验体会:在本次程序的编写和调试过程中，我曾多次修改代码，并根据调试显示的界面一次次调整代码。
数据结构排序PPT课件
注：外部排序时，要将数据分批调入内存来 排序，中间结果还要及时放入外存，显然外 部排序要复杂得多。
在整堂课的教学中，刘教师总是让学 生带着 问题来 学习， 而问题 的设置 具有一 定的梯 度，由 浅入深 ，所提 出的问 题也很 明确
5.待排序记录在内存中怎样存储和处理？
在整堂课的教学中，刘教师总是让学 生带着 问题来 学习， 而问题 的设置 具有一 定的梯 度，由 浅入深 ，所提 出的问 题也很 明确
Void BInsertSort (SqList &L) // 折半插入排序
{ for ( i=2；i<=L.length；++i )
{ L.r[0] = L.r[ i ]； // 将L.r [i] 暂存到L.r[0]
处理方式： ① 顺序排序 —— 数据间的逻辑顺序关系通过其物理
存储位置的相邻来体现，排序时直接移动记录； 适合数据较少的情况！
② 链表排序 ——数据间的逻辑顺序关系通过结点中 的指针体现，排序时只修改指针，不移动数据；
③ 地址排序 —— 数据存储在一段连续地址的空间， 构造一个辅助表保持各数据的存放地址（指针），排 序时先修改辅助表中的地址，最后再移动记录。
在整堂课的教学中，刘教师总是让学 生带着 问题来 学习， 而问题 的设置 具有一 定的梯 度，由 浅入深 ，所提 出的问 题也很 明确
4. 什么叫内部排序？什么叫外部排序？ —— 若待排序记录都在内存中，称为内部排序；
内部排序基本操作有两种： ◆ 比较两个关键字的大小；(比不可少的操作) ◆ 存储位置的移动。
i=8
0
1
2
3
4
数据结构排序算法实验报告
移动次数 735219 247071 2997 7296 22836 4233
乱序 2 比较次数 496238 255211 499500 12927 14868 3788
移动次数 762636 256210 2997 7449 22 242989 499500 12951 14845 3818
希尔排序：void ShellSort(Element *list,int n) 记录移动和比较次数的变量：int countlm=0,countlc=0 希尔排序是将文件分组，然后进行插入排序，因此 countlm,countlc 的增量方式与直 接插入排序相同。
堆排序：void HeapSort(Element *list,const int n) 记录移动和比较次数的变量：int countrm=0,countrc=0 首先进行初始建堆 void Restore(Element *tree,const int root,const int n)，将待排序文 件保存在完全二叉树中，从最后一个非叶节点开始，将其孩子结点与其进行比较， 每比较一次 countrc 加 1，若孩子结点比其大，二者交换 countrm 加 3，直到任意结 点的关键词大于等于它的两个孩子结点。在进行堆排序，将根节点与最后一个叶节 点交换，countrm 加 3，再进行初始建堆，直至完全排好序。
数据结构第七章 排序
name 张涛 赵亮
冯博远 王强 李燕
7.2
基本原理
插入排序
每次将一个待排序的对象，按其关键字大小， 插入到前面已经排序好的一组对象的适当位臵上， 直到对象全部插入为止。
直接插入排序(Insert Sort)
希尔排序(Shell Sort)
7.2.1
直接插入排序
R[1]---R[i-1]
08 08
16 16
第三次
08
16
21
25* 25
49
希尔排序中d（间隔量）的取法 Shell最初的方案是 d= n/2, d=d/2， 直到d=1； Knuth的方案是d= d/3+1；
其它方案有：都取奇数为好；d互质为好 等等。
希尔排序的稳定性
如序列： 21 25 排序后为：08 16
R[0]有两个作用:
其一: 进入查找循环之前，保存 R[i] 的副本，使之不至 于因记录的后移而丢失R[i]中的内容； 其二: 在 while 循环时，“监视”下标变量 j 是否越界， 一旦越界（j<0）,R[0]自动控制while循环的结束, 从而 避免了在while 循环内的每一次都要检测 j 是否越界( 即 省略了循环条件j>=0）。 因此，把 R[0] 称为“监视哨”。
第七章 排 序
本章内容
排序的概念和有关知识
常用的几种排序方法的基本思想、排序过 程和算法实现 各种排序算法的时间复杂度分析
学生成绩表
学号 姓名 高数 英语 总分
005 010 002
018 004
Chen Lin Gao Hong Wang Na
ZhangYang Zhao Pen
84 69 90
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
a[j]=a[i]; /*把a[i]置于a[j]的位置*/
j--; /*前移一个位置*/
}
}
a[i]=mid; /*划分记录到位,一次划分结束*/
quicksort(a,start,i-1); /*递归调用对前一子序列划分*/
quicksort(a,i+1,end); /*递归调用对后一子序列划分*/
{
flag=0;
for(i=1;i<=n-j;i++) /*第j趟共进行n-j次比较*/
if(a[i].key>a[i+1].key)
{
flag=1; /*说明本趟有元素交换*/
temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;
}
if(flag==0)break; /*没有元素交换，说明已排好序*/
}
}
快速排序算法
void quicksort(NODE a[],int start,int end)
/*对a[start]到a[end]的记录按关键字进行快速排序*/
{
int i,j;
NODE mid;
if(start>=end)
return;
i=start;
j=end;
mid=a[i];
while(i<j) /*一次划分直到i等于j*/
图中方框内表示其中数据已移走，可以被其他数据覆盖。
实验过程（实验中涉及的记录、数据、分析）：
冒泡排序算法
void bsort(NODE a[],int n)
/* 对存放在a[1],a[2],…,a[n]中的序列进行冒泡排序 */
{
NODE temp;
int i,j,flag;
for(j=1;j<=n-1;j++) /*共进行n-1趟冒泡*/
}
实验结果：
冒泡算法中外层循环控制冒泡趟数，内层循环控制每趟冒泡时记录关键字的比较次数。在每趟冒泡中，用flag标志量记录是否出现过记录的交换，如果没有出现过交换，说明记录序列已经有序，结束冒泡，这样可避免不必要的计算过程。例如在最好情况下，待排序的记录序列已经有序，程序只需要一趟冒泡，进行n-1次元素的比较。最坏情况下，待排的记录序列为逆序，则程序要完成双重循环的全过程。显然冒泡排序的时间复杂度为O(n2), 并且是稳定的。
例如，一组记录的关键字序列为{ 81，63，45，72 }，冒泡过程如下：
初始状态81 63 45 72
第一趟冒泡后63 45 72 [81]比较了3次
第二趟冒泡后45 63 [72] [81]比较了2次
第三趟冒泡后[45] [63] [72] [81]比较了1次
快速排序的步骤
设待排序的记录序列存放在a数组中，一趟快速排序的步骤如下：
数据结构课程实验报告
学生姓名
学 号
班 级
指导老师
实验名称
交换排序
实验成绩
实验报告
实
验
概
述
实验目的：
掌握冒泡排序和快速排序的基本思想、排序过程、算法实现，能进行时间和空间性能的分析，根据实际问题的特点和要求选择合适的排序方法。
实验要求：
实现冒泡排序和快速排序，比较两种算法的优缺点以及实际应用
实验基本原理：
快速排序的时间复杂度取决于所选划分记录，最坏情况是每次划分记录的关键字正好是记录序列中的最大值或最小值，此时它类似于冒泡法,时间复杂度为O(n2)，在平均情况下快速排序时间复杂度为O(nlog2n)，是目前认为较好的一种内部排序方法。快速排序是不稳定的排序。
实
验
小
结
实
验
内
容
实验设计思路、步骤和方法等：
冒泡排序的步骤
逐次进行相邻记录关键字的比较和必要的换位。首先比较第一个和第二个记录的关键字，将较小的一个放在前面，即第一个位置，较大的放在后面，即第二个位置。然后以同样的方式比较第二个和第三个……，直至完成第n-1个和第n个记录的关键字比较。共进行了n-1次比较，其结果是最大关键字的记录排序到位，并占据了第n个位置，称上述过程为第一趟冒泡。第二趟冒泡对第一个记录到第n-1个记录实施与第一趟冒泡相同的处理。共进行n-2次比较，使次大的关键字记录占据了第n-1个位置。一般的第i趟冒泡从第一个记录到第n-i+1个记录进行两两比较，共进行n-i次比较，直到第n-1趟冒泡，进行第一个记录与第二个记录的一次比较，完成排序。
4.i从当前位置开始从前向后扫描，直到a[i].key>=mid.key ,然后使a[i]置于a[j]直到i和j相等，然后把划分记录置于a[i]中，这样划分记录排序到位，且把原序列划分为要求的两个子序列。称上述过程为一次划分。
例如，一组记录的关键字序列为{ 40，35，60，38，30，90 }，一趟划分的过程如图91所示，其中划分关键字mid=40。
1.选取划分记录，通常设定序列中第一个为划分记录，用变量mid暂存划分记录。另外设置序列的起、止下标，不妨设为start和end。
2.设置两个指示记录下标的变量i、j，初值分别指向序列的起、止位置。
3.j从当前位置开始，从后向前扫描，直到a[j].key<mid.key,然后使a[j]置于a[i]的位置，使i增1，后移一个位置。
冒泡排序是设有n个数据的待排序序列，假设前面1到i-1个数据已经有序，是长度为i-1的有序序列，将第i个数据逐次与第i-1个数据、第i-2个数据……进行比较，直到找到第i个数据的插入位置，并插入得到一个新的长度为i的有序数列。这一过程称为一趟插入，对第i个元素的插入称为第i趟插入
快速排序（Quick Sort）是对冒泡法的改进，算法中经一趟操作后，不仅使某个记录排序到位，同时以该记录的关键字为划分标准（称它为划分记录），把记录序列划分为两个子序列。所有关键字比划分记录小的排放到它的前面，大的排放到它的后面。在原序列中除去划分记录后的两个子序列可以分别进行相同的操作，把每个序列再分成两个更小的子序列，直到序列的长度为1，完成排序。整个排序过程可以通过递归来实现
{
while(i<j &&a[j].key>mid.key)
j--;
if(i<j)
{
a[i]=a[j]; /*把a[j]置于a[i]的位置*/
i++; /*后移一个位置*/
}
while(i<j&&a[i].key<=mid.key)
i++; /*从前向后扫描，等于划分关键字的记录也跳过*/
if(i<j)