冒泡法和快速排序法比较(C++程序)
C语言数组的五种简单排序,选择法排序,冒泡法排序、交换法排序、插入法排序、折半法排序

C语⾔数组的五种简单排序,选择法排序,冒泡法排序、交换法排序、插⼊法排序、折半法排序⽂章⽬录1、选择法排序选择法排序是指每次选择索要排序的数组中的最⼩值(这⾥是由⼩到⼤排序,如果是由⼤到⼩排序则需要选择最⼤值)的数组元素,将这些数组元素的值与前⾯没有进⾏排序的数组元素值进⾏互换代码实现需要注意的是:声明⼀个数组和两个整形变量,数组⽤于存储输⼊的数字,⽽整形变量⽤于存储最⼩的数组元素的数值与该元素的位置,在我的代码中实现为a[] temp position。
代码具体如下#include<stdio.h>int main(){int m,n,k;printf("please input the length of the array:");scanf("%d",&k);int a[k];int temp;int position;printf("please input the number of the array:\n");for(m=0;m<k;m++){printf("a[%d]=",m+1);scanf("%d",&a[m]);}/*从⼩到⼤排序*/for(m=0;m<k-1;m++){temp=a[m]; //设置当前的值为最⼩值position=m; //记录当前的位置for(n=m+1;n<k;n++){if(a[n]<temp){temp=a[n]; //如果找到⽐当前的还要⼩的数值,则更换最⼩的数值与位置position=n;}}a[position]=a[m];a[m]=temp;}for(m=0;m<k;m++){printf("%d\t",a[m]);}return 0;}结果如下2、冒泡法排序冒泡法排序就是值在排序时,每次⽐较数组中相邻的两个数组元素的值,将⽐较⼩的(从⼩到⼤排序算法,如果是从⼤到⼩排序算法就是将较⼤的数排在较⼩的数前⾯)排在⽐较⼤的前⾯在代码实现的过程中:声明⼀个数组与⼀个整型变量,数组⽤于存放数据元素,整型变量⽤于交换时作为中间变量。
c语言中排序的各种方法解析

c语言中排序的各种方法解析一、引言在计算机编程中,排序是一个重要的操作,它按照一定的顺序排列数据元素,使得数据元素按照从小到大的顺序排列。
在C语言中,有多种方法可以实现排序,包括冒泡排序、选择排序、插入排序、快速排序、归并排序等。
这些排序算法都有各自的优缺点,适合不同的应用场景。
二、冒泡排序冒泡排序是一种简单的排序算法,它重复地遍历要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。
遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。
算法步骤:1. 比较相邻的元素。
如果第一个比第二个大(升序),就交换它们两个。
2. 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。
这步做完后,最后的元素会是最大的数。
3. 针对所有的元素重复以上的步骤,除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
三、选择排序选择排序是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素,存放在序列的起始位置,直到全部待排序的数据元素排完。
算法步骤:1. 在未排序序列中找到最小元素,存放到排序序列的起始位置。
2. 再从剩余未排序元素中继续寻找最小元素,然后放到已排序序列的末尾。
3. 以此类推,直到所有元素均排序完毕。
四、插入排序插入排序的工作方式是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序在实现上通常采用in-place排序(即只需用到O(1)的额外空间的排序),因而在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。
五、快速排序快速排序使用了分治的原则,它在每一层划分都比前面方法有所改进和精进,当切分到两边的子序列长度都大于某个值时,或者一个大于一个小于这个值时再进行交换的操作来结束此层的递归过程。
这层的结果又成为下一层的两个子数组来处理,最后就得到递归式的最终结果。
实验3 — 排序方法比较

实验3 —排序方法比较一.实验目的:掌握顺序表的常用排序方法,掌握一种计时方法,测试算法的稳定性。
二.实验内容:1) 分别编写函数实现冒泡排序、快速排序和简单插入排序算法;2) 2路归并排序;3) 编制一个应用程序,它将随机产生的N个0~65535之间的整数插入到一个顺序表中,然后分别用上述排序算法对这个顺序表进行排序;记录并显示各种方法的运行时间;三.源代码:#include"stdio.h"#include"math.h"#include"time.h"#include"stdlib.h"#define SIZE 5000 //每组元素的个数#define SIZE2 12 //每组元素的个数(测试稳定性)struct ele //为了检验算法的稳定性,每个元素设为结构体。
里面有内容和初始顺序。
{int data;int no;};typedef struct ele ELE;void creat(ELE a[],int n);//生成函数void creat2(ELE a[],int n);//生成函数void display(ELE a[],int n);//显示函数void bubble(ELE a[],int n);//冒泡排序函数void insert(ELE a[],int n);//插入排序函数void quick(ELE a[],int low,int high);//快速排序函数int qpass(ELE a[],int low,int high);void merge(ELE a[],ELE b[],int l, int m,int n);void mergepass(ELE a[],ELE b[],int L,int n);void mergesort(ELE a[],ELE b[],int n);//归并排序函数int main(int argc, char* argv[]){ELE a[SIZE];ELE ca[SIZE];//归并排序时使用的缓存结构体数组int i;int start[4],end[4];//记录时间double duration[4];creat(a,SIZE);start[0]=clock();bubble(a,SIZE);end[0]=clock();creat(a,SIZE);start[1]=clock();insert(a,SIZE);end[1]=clock();creat(a,SIZE);start[2]=clock();quick(a,0,SIZE-1);end[2]=clock();creat(a,SIZE);start[3]=clock();mergesort(a,ca,SIZE);end[3]=clock();printf("bubble,insert,quick sort,merge sort\n");for(i=0;i<4;i++){duration[i]=(double)(end[i]-start[i]);printf("持续时间%f\n",duration[i]);}creat2(a,SIZE2);bubble(a,SIZE2);printf("bubble:\n");display(a,SIZE2);creat2(a,SIZE2);insert(a,SIZE2);printf("insert:\n");display(a,SIZE2);creat2(a,SIZE2);quick(a,0,SIZE2-1);printf("quick sort:\n");display(a,SIZE2);creat2(a,SIZE2);mergesort(a,ca,SIZE2);printf("merge sort:\n");display(a,SIZE2);return 0;}void creat(ELE a[],int n){int i;for(i=0;i<n;i++){a[i].data=rand();a[i].no=i;}}void creat2(ELE a[],int n){int i;for(i=0;i<n;i++){a[i].data=rand();if((i%3==1)||(i%3==2))a[i].data=a[i-1].data;a[i].no=i;}}void display(ELE a[],int n){int i;for(i=0;i<n;i++){printf("%d\tInitial NO.%d\n",a[i].data,a[i].no);}printf("\n");}void bubble(ELE a[],int n){int i,j;ELE temp;for(i=0;i<n-1;i++){for(j=0;j<n-1-i;j++){if(a[j+1].data<a[j].data){temp=a[j+1];a[j+1]=a[j];a[j]=temp;}}}}void insert(ELE a[],int n){int i,j;ELE temp;for(i=1;i<n;i++){temp=a[i];j=i-1;while(temp.data<a[j].data){a[j+1]=a[j];j--;}a[j+1]=temp;}}int qpass(ELE a[],int low,int high){int i,j,k;ELE x;i=low;j=high;x=a[low];k=a[low].data;while(i<j){while((i<j)&&(a[j].data>=k))j--;a[i]=a[j];while((i<j)&&(a[i].data<=k))i++;a[j]=a[i];}a[i]=x;return i;}void quick(ELE a[],int low,int high){int i;if(low<high){i=qpass(a,low,high);quick(a,low,i-1);quick(a,i+1,high);}}void merge(ELE a[],ELE b[],int l, int m,int n) {int i,j,k;i=l;j=m+1;k=l;while((i<=m)&&(j<=n)){if(a[i].data<=a[j].data){b[k]=a[i];i++;}else{b[k]=a[j];j++;}k++;}if(i>m)for(;j<=n;j++,k++)b[k]=a[j];elsefor(;i<=m;i++,k++)b[k]=a[i];}void mergepass(ELE a[],ELE b[],int L,int n) {int i,j;i=0;while(i+2*L-1<n){merge(a,b,i,i+L-1,i+2*L-1);i=i+2*L;}if(i+L-1<n)merge(a,b,i,i+L-1,n);elsefor(j=i;j<n;j++)b[j]=a[j];}void mergesort(ELE a[],ELE b[],int n) {int L,i;n-=1;L=1;while(L<n){mergepass(a,b,L,n);L=2*L;if(L<n){mergepass(b,a,L,n);L=2*L;}elsefor(i=0;i<=n;i++)a[i]=b[i];}}四.截图:五.总结:通过实验使我对四种排序方法有了更好的认识,加深了对c语言的认识。
C语言八大排序算法

C语⾔⼋⼤排序算法C语⾔⼋⼤排序算法,附动图和详细代码解释!来源:C语⾔与程序设计、⽵⾬听闲等⼀前⾔如果说各种编程语⾔是程序员的招式,那么数据结构和算法就相当于程序员的内功。
想写出精炼、优秀的代码,不通过不断的锤炼,是很难做到的。
⼆⼋⼤排序算法排序算法作为数据结构的重要部分,系统地学习⼀下是很有必要的。
1、排序的概念排序是计算机内经常进⾏的⼀种操作,其⽬的是将⼀组“⽆序”的记录序列调整为“有序”的记录序列。
排序分为内部排序和外部排序。
若整个排序过程不需要访问外存便能完成,则称此类排序问题为内部排序。
反之,若参加排序的记录数量很⼤,整个序列的排序过程不可能在内存中完成,则称此类排序问题为外部排序。
2、排序分类⼋⼤排序算法均属于内部排序。
如果按照策略来分类,⼤致可分为:交换排序、插⼊排序、选择排序、归并排序和基数排序。
如下图所⽰:3、算法分析1.插⼊排序*直接插⼊排序*希尔排序2.选择排序*简单选择排序*堆排序3.交换排序*冒泡排序*快速排序4.归并排序5.基数排序不稳定排序:简单选择排序,快速排序,希尔排序,堆排序稳定排序:冒泡排序,直接插⼊排序,归并排序,奇数排序1、插⼊排序将第⼀个和第⼆个元素排好序,然后将第3个元素插⼊到已经排好序的元素中,依次类推(插⼊排序最好的情况就是数组已经有序了)因为插⼊排序每次只能操作⼀个元素,效率低。
元素个数N,取奇数k=N/2,将下标差值为k的数分为⼀组(⼀组元素个数看总元素个数决定),在组内构成有序序列,再取k=k/2,将下标差值为k的数分为⼀组,构成有序序列,直到k=1,然后再进⾏直接插⼊排序。
3、简单选择排序选出最⼩的数和第⼀个数交换,再在剩余的数中⼜选择最⼩的和第⼆个数交换,依次类推4、堆排序以升序排序为例,利⽤⼩根堆的性质(堆顶元素最⼩)不断输出最⼩元素,直到堆中没有元素1.构建⼩根堆2.输出堆顶元素3.将堆低元素放⼀个到堆顶,再重新构造成⼩根堆,再输出堆顶元素,以此类推5、冒泡排序改进1:如果某次冒泡不存在数据交换,则说明已经排序好了,可以直接退出排序改进2:头尾进⾏冒泡,每次把最⼤的沉底,最⼩的浮上去,两边往中间靠16、快速排序选择⼀个基准元素,⽐基准元素⼩的放基准元素的前⾯,⽐基准元素⼤的放基准元素的后⾯,这种动作叫分区,每次分区都把⼀个数列分成了两部分,每次分区都使得⼀个数字有序,然后将基准元素前⾯部分和后⾯部分继续分区,⼀直分区直到分区的区间中只有⼀个元素的时候,⼀个元素的序列肯定是有序的嘛,所以最后⼀个升序的序列就完成啦。
c语言数组数据比较算法

c语言数组数据比较算法概述在C语言中,数组是一种常见的数据结构,用于存储一系列相同数据类型的元素。
在实际编程中,经常需要对数组进行比较操作,以找到数组中的最大值、最小值、排序等。
本文将详细介绍C语言中常用的数组数据比较算法。
一、数组元素比较1.1 逐个元素比较法逐个元素比较法是最简单的数组比较方法,其基本思想是将两个数组中的对应元素逐个进行比较,找出差异或相同之处。
具体步骤如下:1.声明两个数组a和b;2.逐个比较数组a和数组b的对应元素;3.如果找到不同的元素,输出差异;4.如果所有对应元素都相同,则输出相同。
1.2 利用循环遍历比较法逐个元素比较法虽然简单,但需要逐个比较所有元素,效率较低。
利用循环遍历比较法可以通过循环结构实现更高效的数组比较。
具体步骤如下: 1. 声明两个数组a和b; 2. 使用循环结构遍历数组a和数组b的对应元素; 3. 逐个比较数组a 和数组b的对应元素; 4. 如果找到不同的元素,输出差异; 5. 如果所有对应元素都相同,则输出相同。
二、数组排序算法2.1 冒泡排序法冒泡排序是一种简单的排序算法,其基本思想是多次遍历数组,每次遍历都将相邻的两个元素进行比较并交换位置,从而实现将最大(或最小)元素逐渐移到数组的末尾(或开头)。
具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第一个元素到倒数第二个元素; 3. 内层循环遍历数组元素,从第一个元素到当前外层循环变量所指示的位置; 4. 逐个比较相邻的两个元素,如果前一个元素大于后一个元素,则交换它们的位置; 5. 继续下一轮的遍历,直到所有元素排序完成。
2.2 插入排序法插入排序是一种简单直观的排序算法,其基本思想是将数组分为已排序和未排序两部分,每次从未排序部分取出一个元素,插入到已排序部分的适当位置。
具体步骤如下: 1. 声明一个数组a; 2. 外层循环遍历数组元素,从第二个元素到最后一个元素; 3. 内层循环从外层循环变量所指示的位置开始,向前逐个比较并移动已排序部分的元素; 4. 当找到合适位置时,插入当前未排序元素; 5. 继续下一轮的遍历,直到所有元素排序完成。
常用的选择类排序方法

常用的选择类排序方法一、冒泡排序法冒泡排序法是一种简单直观的排序方法,它重复地遍历要排序的列表,比较相邻的元素并按照大小交换位置,直到整个列表排序完成。
该方法的时间复杂度为O(n^2),在大规模数据排序时效率较低。
冒泡排序的优点是实现简单,代码易于理解和实现。
二、插入排序法插入排序法是一种稳定的排序方法,它通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
插入排序法的时间复杂度为O(n^2),但是在小规模数据排序时效率较高。
插入排序的优点是实现简单,对于部分有序的数据集合,排序效率较高。
三、选择排序法选择排序法是一种简单直观的排序方法,它将待排序的列表分为有序和无序两部分,每次从无序部分选择最小(或最大)的元素放到有序部分的末尾,直到整个列表排序完成。
选择排序法的时间复杂度为O(n^2),在大规模数据排序时效率较低。
选择排序的优点是实现简单,对于大规模数据排序时空间复杂度较低。
四、快速排序法快速排序法是一种常用的排序方法,它基于分治的思想,通过递归地将列表分成较小和较大的两个子序列,然后对子序列进行排序,最后将排序好的子序列合并成有序的列表。
快速排序法的时间复杂度为O(nlogn),在大规模数据排序时效率较高。
快速排序的优点是实现简单,排序速度快。
五、归并排序法归并排序法是一种稳定的排序方法,它通过将列表递归地分成较小的子序列,对子序列进行排序,然后将排序好的子序列合并成有序的列表。
归并排序法的时间复杂度为O(nlogn),在大规模数据排序时效率较高。
归并排序的优点是稳定性好,适用于大规模数据排序。
六、堆排序法堆排序法是一种常用的排序方法,它利用堆这种数据结构进行排序。
堆是一棵完全二叉树,可以通过数组来表示。
堆排序法通过构建最大堆或最小堆,将堆的根节点与最后一个叶子节点交换,然后重新调整堆,直到整个列表排序完成。
堆排序法的时间复杂度为O(nlogn),在大规模数据排序时效率较高。
C语言内排序法实验报告
数据结构一:排序方法比较1、冒泡排序属于稳定排序,是一种借助“交换”进行排序的方法。
首先要将第一个记录的关键字和第二个记录的关键字进行比较,若为逆序,则将两个记录交换之,然后比较第二个记录与第三个记录的关键字,以此类推,直至第n-1个记录与第n个记录的关键字进行比较为止,这一过程称为第一趟冒泡排序,其结果使得关键字最大的记录被安置在最后一个记录的位置上;然后进行第二趟冒泡排序,对前N-1个记录进行同样操作;以此类推,直到在一趟排序过程中没有进行过交换记录的操作为止。
2、直接插入排序属于稳定的排序,每次从无序表中取出第一个元素,把它插入到有序表的合适位置,使有序表仍然有序。
第一趟将待比较的数值与它的前一个数值进行比较,当前一数值比待比较数值大的情况下继续循环比较,依次进行下去,进行了(n-1)趟扫描以后就完成了整个排序过程,结束该次循环。
3、快速排序属于不稳定排序,是对起泡排序的一种改进。
它的基本思想是,通过一趟排序将待排记录分割成独立的两部分,其中一部分记录的关键字均比另一部分记录的关键字小,则可分别对这两部分记录继续进行排序,以达到整个序列有序。
假设待排序的序列为{R.[s],R.[s+1],…….,R.[t]},首先任意选取一个记录,然后按下述原则从新排序记录:将关键字较他小的记录都安置在他的位置之前,将所有关键字较他大的记录都安置在他的位置后面。
由此可以该“枢轴”记录最后所落的位置i作为分界线,将序列{R[s],R[s+1]…….R[t]}分割成两个子序列{R[s],R[s+1]…..R[i-1]}和{R[i+1]……R[t]},这个过程称作一趟快速排序。
一趟快速排序的具体做法是:附设两个指针low和high,它们的初值分别指向数组第一个数据和最后一个数据,将枢轴记录暂存在R[0]的位置上排序过程中只作R[low]或R[high]的单向移动,直至一趟排序结束后再将枢轴记录移至正确位置上。
4、简单选择排序属于不稳定排序,基本思想是,每一趟在n-i+1(i=1,2,…n-1)个记录中选取关键字最小的记录作为有序序列中第i个记录。
国家二级C语言机试(选择题)模拟试卷278(题后含答案及解析)
国家二级C语言机试(选择题)模拟试卷278(题后含答案及解析) 题型有:1.1.以下选项中关于程序模块化的叙述错误的是A.把程序分成若干相对独立、功能单一的模块,可便于重复使用这些模块B.可采用自底向上、逐步细化的设计方法把若干独立模块组装成所要求的程序C.把程序分成若干相对独立的模块,可便于编码和调试D.可采用自顶向下、逐步细化的设计方法把若干独立模块组装成所要求的程序正确答案:B解析:如果应用结构化程序设计方法设计程序,那么可采用自顶向下,逐步细化的设计方法把若干独立模块组装成所要求的程序。
知识模块:C语言基础知识2.我们所写的每条C语句,经过编译最终都将转换成二进制的机器指令。
关于转换以下说法错误的是A.一条C语句可能会被转换成多条机器指令B.一条C语句对应转换成一条机器指令C.一条C语句可能会被转换成零条机器指令D.某种类型和格式的C语句被转换成机器指令的条数是崮定的正确答案:B解析:由C语言编写的程序,通过编译、链接转换成可以让机器识别的01二进制指令。
这些二进制指令命令机器计算,这些就是机器指令,而C语言的语言条数和机器指令的条数不是一对一的关系。
知识模块:C语言基础知识3.面向对象方法中,实现对象的数据和操作结合于统一体中的是( )。
A.结合B.封装C.隐藏D.抽象正确答案:B解析:对象的基本特点是:标识唯一性、分类性、多态性、封装性、模块独立性好。
封装是指隐藏对象的属性和实现细节,将数据和操作结合于统一体中,仅对外提供访问方式。
B选项正确。
知识模块:公共基础知识4.以下叙述中正确的是A.程序必须包含所有三种基本结构才能成为一种算法B.如果算法非常复杂,则需要使用三种基本结构之外的语句结构,才能准确表达C.只有简单算法才能在有限的操作步骤之后结束D.我们所写的每条C语句,经过编译最终都将转换成二进制的机器指令正确答案:D解析:C语句构成了函数,函数构成的程序,经过编译转换成二进制代码后可以运行,算法是指为解决某个特定问题而采取的确定且有限的步骤,可以利用代码来描述算法,而算法+数据结构才是程序,结构化的程序由顺序结构、循环结构和选择结构三种基本结构组成。
c语言几种数组排序方法
常用的c语言排序算法主要有三种即冒泡法排序、选择法排序、插入法排序。
一、冒泡排序冒泡排序:是从第一个数开始,依次往后比较,在满足判断条件下进行交换。
代码实现(以降序排序为例)#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp;for (int i = 0; i < 10; i++){//循环次数for (int j = 0; j <10 - i-1; j++){if (array[j] < array[j+1]){//前面一个数比后面的数大时发生交换temp = array[j];array[j] = array[j+1];array[j + 1] = temp;}}} //打印数组for (int i = 0; i < 10; i++) printf("%2d", array[i]); return 0;}}二、选择排序以升序排序为例:就是在指定下标的数组元素往后(指定下标的元素往往是从第一个元素开始,然后依次往后),找出除指定下标元素外的值与指定元素进行对比,满足条件就进行交换。
与冒泡排序的区别可以理解为冒泡排序是相邻的两个值对比,而选择排序是遍历数组,找出数组元素与指定的数组元素进行对比。
(以升序为例)#include<stdio.h>int main(){int array[10] = { 6,9,7,8,5,3,4,0,1,2 };int temp, index;for (int i = 0; i < 9; i++) {index = i;for (int j = i; j < 10; j++){if (array[j] < array[index])index = j;}if(i != index){temp = array[i]; array[i] = array[index]; array[index] = temp; }for(int i=0;i<10:i++) printf("%2d"array[i])return 0;}三、快速排序是通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。
冒泡排序和快速排序的性能比较
课程设计题目快速、冒泡排序算法比较学院计算机科学与技术专业计算机科学与技术班级计科1004班姓名李骄指导教师施继珉2012 年 6 月20 日课程设计任务书学生姓名:李骄专业班级: 1004 班指导教师:施继珉工作单位:计算机科学系题目:快速、冒泡排序算法比较初始条件:试通过随机数据比较快速排序、起泡排序各算法的关键字比较次数和关键字移动次数。
(1)待排序表的表长不小于100;其中的数据要用伪随机数产生程序产生;至少要用5组不同的输入数据作比较;比较的指标为有关键字参加的比较次数和关键字的移动次数(关键字交换计为3次移动)。
(2)最后要对结果作出简单分析,包括对各组数据得出结果波动大小的解释。
(3)对冒泡排序应指出进行了多少趟。
要求完成的主要任务:(包括课程设计工作量及其技术要求,以及说明书撰写等具体要求)课程设计报告按学校规定格式用A4纸打印(书写),并应包含如下内容:1、问题描述简述题目要解决的问题是什么。
2、设计存储结构设计、主要算法设计(用类C语言或用框图描述)、测试用例设计;3、调试报告调试过程中遇到的问题是如何解决的;对设计和编码的讨论和分析。
4、经验和体会(包括对算法改进的设想)5、附源程序清单和运行结果。
源程序要加注释。
如果题目规定了测试数据,则运行结果要包含这些测试数据和运行输出,6、设计报告、程序不得相互抄袭和拷贝;若有雷同,则所有雷同者成绩均为0分。
时间安排:1、第19周完成。
2、6月22 日14:00到计算中心检查程序、交课程设计报告、源程序(CD盘)。
指导教师签名:年月日系主任(或责任教师)签名:年月日一问题描述1.深刻理解冒泡排序和快速排序的定义和特点,掌握两个排序的方法,并学会用高级语言实现算法的方法。
2.理解两种排序的过程及其依据的原则,掌握排序算法的时间复杂度和稳定性的分析方法。
3.通过对冒泡排序和快速排序的性能分析和比较得出优劣,由此更加理解在不同条件下选择哪种算法。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
冒泡法和快速排序法比较(多文档形式)
/*************************************
快速排序.cpp
*************************************/
int quick_sort(int *x,int low,int high)
{
int i,j,t,k=0;
if (low<high) /*要排序的元素起止下标,保证小的放在左边,大的放在右边。
这里以下标为low的元素为基准点*/
{
i=low;
j=high;
t=*(x+low); /*暂存基准点的数*/
while (i<j) /*循环扫描*/
{
while (i<j && *(x+j)>t) /*在右边的只要比基准点大仍放在右边*/
{
j--;/*前移一个位置*/
}
if (i<j)
{
*(x+i) = *(x+j); /*上面的循环退出:即出现比基准点小的数,替换基准点的数*/
i++;k++; /*后移一个位置,并以此为基准点*/
}
while (i<j && *(x+i)<=t) /*在左边的只要小于等于基准点仍放在左边*/
{
i++; /*后移一个位置*/
}
if (i<j)
{
*(x+j) = *(x+i); /*上面的循环退出:即出现比基准点大的数,放到右边*/
j--;k++; /*前移一个位置*/
}
}
*(x+i) = t; /*一遍扫描完后,放到适当位置*/
quick_sort(x,low,i-1); /*对基准点左边的数再执行快速排序*/
quick_sort(x,i+1,high); /*对基准点右边的数再执行快速排序*/
return k;
}
/*************************************
冒泡法.cpp
*************************************/
#include <stddef.h>
int sortmao(int *p,int n,int flag) //冒泡法对整型数排序:p数组指针,n排序个数,flag为正递增排序负则递减排序
{
int i,j,temp,k=0;
if(p==NULL||n<0||flag==0)
return k;
for(i=1;i<n;i++)
for(j=0; j<n-i; j++)
if(flag>0&&*(p+j)>*(p+j+1)||flag<0&&*(p+j)<*(p+j+1))
{temp=*(p+j);
*(p+j)=*(p+j+1);
*(p+j+1)=temp;k++;}
return k;
}
/*************************************
冒泡和快速排序法.cpp
*************************************/
#include <iostream.h>
#include "冒泡法.cpp"
#include "快速排序.cpp"
#define N 10
#define M 1 //M 为正时,冒泡法排序中递增排序,M为负时,冒泡法排序中递减排序
int quicksort();
void main()
{
int a[N],b[N];
int i;
cout<<"请输入"<<N<<"个数:"<<endl;
for(i=0;i<N;i++)
cout<<"第"<<i+1<<"个数:";
cin>>a[i];
}
for(i=0;i<N;i++)
b[i]=a[i];
cout<<"冒泡法排序次数为:"<<sortmao(a,N,M)<<endl;
for(i=0;i<N;i++)
cout<<a[i]<<"\t";cout<<endl;
cout<<"快速排序法排序次数为:"<<quick_sort(b,0,N)<<endl;
for(i=0;i<N;i++)
cout<<b[i]<<"\t";cout<<endl;
}。