C语言冒泡排序法
冒泡排序每一趟排序把最大的放在最右边。
比如:
87 12 56 45 78
87和12交换:12 87 56 45 78
87和56交换: 56 87 45 78
87和45交换: 45 87 78
87和78交换: 78 87
到此第一趟排序结束,接下来的每一趟排序都是这样。
#includevoid Print(int *num, int n){ int i; for(i = 0; i num[j + 1]) { int temp = num[j]; num[j] = num[j + 1]; num[j + 1] = temp; } Print(num, n); } } return;}int main(){ int num[8] = {87, 12, 56, 45, 78}; Bubble_Sort(num, 5); return 0;}
冒泡排序每一趟排序把最大的放在最右边。
比如:
87 12 56 45 78
87和12交换:12 87 56 45 78
87和56交换: 56 87 45 78
87和45交换: 45 87 78
87和78交换: 78 87
到此第一趟排序结束,接下来的每一趟排序都是这样。
#include<stdio.h>
void Print(int *num, int n)
{
int i;
for(i = 0; i < n; i++)
printf("%d ", num[i]);
puts("
");
return;
}
void Bubble_Sort(int *num, int n)
{
int i, j;
for(i = 0; i < n; i++)
{
for(j = 0; i + j < n - 1; j++)
{
if(num[j] > num[j + 1])
{
int temp = num[j];
num[j] = num[j + 1];
num[j + 1] = temp;
}
Print(num, n);
}
}
return;
}
int main()
{
int num[8] = {87, 12, 56, 45, 78};
Bubble_Sort(num, 5);
return 0;
}
#include<stdio.h>
void main()
{
int a[10];
int i,j,t;
printf("input 10 numbers:
");
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(j=0;j<9;j++) /*进行9次循环 实现9趟比较*/
for(i=0;i<9-j;i++) /*在每一趟中进行9-j次比较*/
if(a[i]>a[i+1]) /*相邻两个数比较,想降序只要改成a[i]<a[i+1]*/
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
}
printf("the sorted numbers:
");
for(i=0;i<10;i++)
printf(" %d",a[i]);
}
扩展资料:
冒泡排序算法的运作
1、比较相邻的元素。如果第一个比第二个大(小),就交换他们两个。
2、对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大(小)的数。
3、针对所有的元素重复以上的步骤,除了最后已经选出的元素(有序)。
4、持续每次对越来越少的元素(无序元素)重复上面的步骤,直到没有任何一对数字需要比较,则序列最终有序。
简单的表示
#include <stdio.h>
void swap(int *i, int *j)
{
int temp = *i;
*i = *j;
*j = temp;
}
int main()
{
int a[10] = {2,1,4,5,6,9,7,8,7,7};
int i,j;
for (i = 0; i < 10; i++)
{
for (j = 9; j > i; j--)//从后往前冒泡
{
if (a[j] < a[j-1])
{
swap(&a[j], &a[j-1]);
}
}
}
for (i = 0; i < 10; i++)
{
printf("%d
", a[i]);
}
return 0;
}
参考资料来源:冒泡排序-百度百科
main()
{
int i,j,temp;
int a[10];
for(i=0;i<10;i++)
scanf ("%d,",&a[i]);
for(j=0;j<=9;j++)
{ for (i=0;i<10-j;i++)
if (a[i]>a[i+1])
{ temp=a[i];
a[i]=a[i+1];
a[i+1]=temp;}
}
for(i=1;i<11;i++)
printf("%5d,",a[i] );
printf("\n");
}
--------------
冒泡算法
冒泡排序的算法分析与改进
交换排序的基本思想是:两两比较待排序记录的关键字,发现两个记录的次序相反时即进行交换,直到没有反序的记录为止。
应用交换排序基本思想的主要排序方法有:冒泡排序和快速排序。
冒泡排序
1、排序方法
将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。
(1)初始
R[1..n]为无序区。
(2)第一趟扫描
从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下、重者在上,则交换二者的位置。即依次比较(R[n],R[n-1]),(R[n-1],R[n-2]),…,(R[2],R[1]);对于每对气泡(R[j+1],R[j]),若R[j+1].key<R[j].key,则交换R[j+1]和R[j]的内容。
第一趟扫描完毕时,"最轻"的气泡就飘浮到该区间的顶部,即关键字最小的记录被放在最高位置R[1]上。
(3)第二趟扫描
扫描R[2..n]。扫描完毕时,"次轻"的气泡飘浮到R[2]的位置上……
最后,经过n-1 趟扫描可得到有序区R[1..n]
注意:
第i趟扫描时,R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时,该区中最轻气泡飘浮到顶部位置R上,结果是R[1..i]变为新的有序区。
2、冒泡排序过程示例
对关键字序列为49 38 65 97 76 13 27 49的文件进行冒泡排序的过程
3、排序算法
(1)分析
因为每一趟排序都使有序区增加了一个气泡,在经过n-1趟排序之后,有序区中就有n-1个气泡,而无序区中气泡的重量总是大于等于有序区中气泡的重量,所以整个冒泡排序过程至多需要进行n-1趟排序。
若在某一趟排序中未发现气泡位置的交换,则说明待排序的无序区中所有气泡均满足轻者在上,重者在下的原则,因此,冒泡排序过程可在此趟排序后终止。为此,在下面给出的算法中,引入一个布尔量exchange,在每趟排序开始前,先将其置为FALSE。若排序过程中发生了交换,则将其置为TRUE。各趟排序结束时检查exchange,若未曾发生过交换则终止算法,不再进行下一趟排序。
(2)具体算法
void BubbleSort(SeqList R)
{ //R(l..n)是待排序的文件,采用自下向上扫描,对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(外循环)
} //BubbleSort
4、算法分析
(1)算法的最好时间复杂度
若文件的初始状态是正序的,一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数M均达到最小值:
Cmin=n-1
Mmin=0。
冒泡排序最好的时间复杂度为O(n)。
(2)算法的最坏时间复杂度
若初始文件是反序的,需要进行n-1趟排序。每趟排序要进行n-i次关键字的比较(1≤i≤n-1),且每次比较都必须移动记录三次来达到交换记录位置。在这种情况下,比较和移动次数均达到最大值:
Cmax=n(n-1)/2=O(n2)
Mmax=3n(n-1)/2=O(n2)
冒泡排序的最坏时间复杂度为O(n2)。
(3)算法的平均时间复杂度为O(n2)
虽然冒泡排序不一定要进行n-1趟,但由于它的记录移动次数较多,故平均时间性能比直接插入排序要差得多。
(4)算法稳定性
冒泡排序是就地排序,且它是稳定的。
5、算法改进
上述的冒泡排序还可做如下的改进:
(1)记住最后一次交换发生位置lastExchange的冒泡排序
在每趟扫描中,记住最后一次交换发生的位置lastExchange,(该位置之前的相邻记录均已有序)。下一趟排序开始时,R[1..lastExchange-1]是有序区,R[lastExchange..n]是无序区。这样,一趟排序可能使当前有序区扩充多个记录,从而减少排序的趟数。具体算法【参见习题】。
(2) 改变扫描方向的冒泡排序
①冒泡排序的不对称性
能一趟扫描完成排序的情况:
只有最轻的气泡位于R[n]的位置,其余的气泡均已排好序,那么也只需一趟扫描就可以完成排序。
【例】对初始关键字序列12,18,42,44,45,67,94,10就仅需一趟扫描。
需要n-1趟扫描完成排序情况:
当只有最重的气泡位于R[1]的位置,其余的气泡均已排好序时,则仍需做n-1趟扫描才能完成排序。
【例】对初始关键字序列:94,10,12,18,42,44,45,67就需七趟扫描。
②造成不对称性的原因
每趟扫描仅能使最重气泡"下沉"一个位置,因此使位于顶端的最重气泡下沉到底部时,需做n-1趟扫描。
③改进不对称性的方法
在排序过程中交替改变扫描方向,可改进不对称性
复制过来的!
//以下以四个数字的给举例,便于理解;
#include <stdio.h>
main()
{
int i; //定义i变量,i代表外层for循环--比较轮数;
int k; //定义k变量,k代表内层for循环--比较次数;
int t; //定义t变量,t代表临时变量,临时存放比较的结果中较大的数字,通过赋值的方式切换数字的排序;
int a[] = {30,3,6,10}; //定义数组,数组是本次要排序的数字组合;注意此处数组中一共4个数字所以 理论上是 a[4]={30,3,6,10};
//初试化i=1;并判断i是否小于等于3; 如果符合条件 那么进入for循环;(4个数字,两两对比需要进行3轮对比,i就代表了轮数;i需要经过 1,2,3 三轮的赋值;i=4的时候会跳出for循环)
for(i=1; i<=3; i++){
//初试化k=0;并判断k是否小于等于3 -i; 如果符合条件 那么进入for循环;第一轮的时候数组一共4个数字所以需要对比3次;第二轮还有3个数字需要对比2次;第三轮仅剩2个数字需要对比1次;(特:当k=0的时候是第一次对比;k从0开始赋值是为了在for循环内当数组的键值使用;)
for(k=0; k<=3-i; k++){
//判断a[K] 的数字 是否 大于 a[K + 1 ] 的数字;假设当前是第一轮第一次对比那么a[K=0] = 30,a[K=0 + 1] = 3;
if(a[k] > a[k+1]){
t = a[k]; //对上一步判断结果进行进一步处理,因为a[K] > a[K + 1 ] , 所以把a[K] 赋值给临时变量以便于 后续把这个大的数字向后平移;
a[k] = a[k+1]; //a[K + 1 ]是比较结果中比较小的数字,所以需要向前靠,向前靠就是要赋值给 a[K];空出 a[K + 1 ]便于下一步接收 较大的数字 a[K];
a[k+1] = t; //a[K + 1 ] 接收 较大的数字 a[K];
}
}
}
for(i=0; i<4; i++){//初试化i=0;并判断i是否小于4; 如果符合条件 那么进入for循环,i在for内做键值使用:
printf("第 %d个数字为:%d
",i+1,a[i]);
}
}
/*
运行结果如下:
第 1个数字为:3
第 2个数字为:6
第 3个数字为:10
第 4个数字为:30
*/
C语言冒泡排序法的排序规则:
将被排序的记录数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡。根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"。如此反复进行,直到最后任何两个气泡都是轻者在上,重者在下为止。
初始 R[1..n]为无序区。
第一趟扫描 从无序区底部向上依次比较相邻的两个气泡的重量,若发现轻者在下、重者在上,则交换二者的位置。
即依次比较(R[n],R[n-1]),(R[n-1],R[n-2]),…,(R[2],R[1]);对于每对气泡(R[j+1],R[j]),若R[j+1].key<R[j].key,则交换R[j+1]和R[j]的内容。 第一趟扫描完毕时,"最轻"的气泡就飘浮到该区间的顶部,即关键字最小的记录被放在最高位置R[1]上。
第二趟扫描 扫描R[2..n]。
扫描完毕时,"次轻"的气泡飘浮到R[2]的位置上…… 最后,经过n-1 趟扫描可得到有序区R[1..n] 注意: 第i趟扫描时,R[1..i-1]和R[i..n]分别为当前的有序区和无序区。扫描仍是从无序区底部向上直至该区顶部。扫描完毕时,该区中最轻气泡飘浮到顶部位置R上,结果是R[1..i]变为新的有序区。
C语言:冒泡排序法(升序排序法)
C语言中,冒泡排序法是一种用于升序排列数字或字符的简单算法。以下是两种情况的代码示例:对于数字的排序:使用C语言的冒泡排序法,可以对数组如12, 43, 9, 13, 67, 98, 101, 89, 3, 35进行升序排列。代码中,通过嵌套循环,比较相邻元素并交换位置,直到整个数组有序。对于字符的排序:对于字符...
用语言描述冒泡排序的实现
冒泡排序是一种简单的排序算法,它通过反复交换相邻的未排序元素,使得每一轮迭代后最大的元素能“冒”到其应在的位置,从而达到排序的目的。冒泡排序的基本原理是,从数组的第一个元素开始,比较相邻的两个元素,如果它们的顺序错误就把它们交换过来。这样,每一对相邻元素进行比较和可能的交...
c语言中冒泡排序是怎么工作的?
原理就是运用冒泡算法,把最大的数浮在最上面,而小的数就下沉,最后就输出。
C语言冒泡排序法代码
1. 冒泡排序是一种简单的排序算法,它通过重复地遍历要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过来。2. 冒泡排序的基本思想是不断地从数列中取出最大的元素,放到最后。3. 例如,对于数列 87, 12, 56, 45, 78,首先比较 87 和 12,发现顺序错误,交换它们,得到 12, 87...
C语言冒泡排序法是什么?
冒泡排序法,是C语言常用的排序算法之一,意思是对一组数字进行从大到小或者从小到大排序的一种算法。具体方法是:相邻数值两两交换。从第一个数值开始,如果相邻两个数的排列顺序与我们的期望不同,则将两个数的位置进行交换(对调);如果其与我们的期望一致,则不用交换。重复这样的过程,一直到...
用语言描述冒泡排序的实现
冒泡排序是一种简单的排序算法,它通过重复遍历要排序的数列,比较每对相邻元素的值,若发现顺序错误则交换它们的位置。这个过程重复进行,直到没有再需要交换的元素,即数列已经排序完成。具体来说,冒泡排序从数列的第一对元素开始比较,如果前一个元素比后一个元素大(假设为升序排序),则交换它们的...
c语言实现冒泡排序法
1. 在终端中打开Vim,创建一个名为bubble.c的新文件。输入`#include `,以便使用`printf`函数。2. 定义一个名为`sort`的函数,它接受一个整数指针`a`和整数`n`作为参数。这个函数的目的是对数组`a`进行冒泡排序,数组的长度为`n`。3. 使用两层嵌套循环来实现冒泡排序算法。外层循环控制整个排序...
C语言中冒泡排序法和选择排序法有哪些不同
1、冒泡排序法:一趟一趟的将两个相邻的数进行交换如果有10个数则需要排9躺,如果是从 大到小输出则需要每次将后一个数和前一个数进行比较将较大的数赋值给钱一个数,将较小的数赋值给后一个数,其实就是两个数交换,那么第一趟交换完毕后,最 小的数便出现在了数组的最后面,然后进行第二趟...
c语言冒泡排序程序怎么写?
冒泡排序需要用到两层循环,第一层循环遍历数组中的元素,第二层则进行两两比较,如果顺序不对就要对其进行换位,直到排序完成:4、最后执行程序观察结果,按下crtl+F5弹出程序,随意输入10个数,按下回车键执行结果,此时就可以看到排序后的结果了。以上就是c语言冒泡排序程序的演示:
C语言冒泡排序法代码是什么?
所谓冒泡排序法,就是对一组数字进行从大到小或者从小到大排序的一种算法。1、具体方法是,相邻数值两两交换。从第一个数值开始,如果相邻两个数的排列顺序与我们的期望不同,则将两个数的位置进行交换(对调);如果其与我们的期望一致,则不用交换。重复这样的过程,一直到最后没有数值需要交换,则...
雷缸华仁: 冒泡排序每一趟排序把最大的放在最右边. 比如: 87 12 56 45 78 87和12交换:12 87 56 45 78 87和56交换: 56 87 45 78 87和45交换: 45 87 78 87和78交换: 78 87 到此第一趟排序结束,接下来的每一趟排序都是这样.1 2 3 4 5 6 7 8 9 ...
江源区19543924746: C语言冒泡排序法是怎么排序的? - ?
雷缸华仁: C语言冒泡排序法的排2113序规则:5261将被排序的记录4102数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡1653.根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上"飘浮"...
江源区19543924746: c语言中冒泡法是什么意思? - ?
雷缸华仁: 冒泡法是一种排序方法 冒泡法5 4 3 2 1 比如上面这5个数字我们把它按照由小到大的顺序排列, 从前往后相临两位比较大小,如果前一位比后一位大就把它俩 换位,5比4大就把5和4换位,得到45321 5又比3大 5和3换位 得到43521 依次类...
江源区19543924746: 求关于c语言 冒泡排序法的讲解 - ?
雷缸华仁: 冒泡排序法是简单的排序方法之一,它和气泡从水中往上冒的情况有 些类似.其具体做法是(1)对于数组a中的1至n个数据,先将第n个和第n-1个数据进行比较,如果 a(n)<a(n-1),则两个数交换位置. 然后比较第n-1个和第n-2个数据;依次...
江源区19543924746: c语言的冒泡排序 - ?
雷缸华仁: #include <iostream> using namespace std; int main() { int a[11];int i,j,k;for(i=0;i<10;i++)cin>>a[i]; for(i=0;i<10;i++)for(j=i+1;j<10;j++) //注意这里j=i+1if(a[i]<a[j]){k=a[i];a[i]=a[j];a[j]=k;} for(k=0;k<10;k++)cout<<a[k]<<","; system("pause"); return 0; }
江源区19543924746: 请讲解下C语言的冒泡排序法 - ?
雷缸华仁: 冒泡法,就是通过多次循环排序的一种方法. 第一次循环,让最小(最大)的值浮到第一位, 第二次循环,让剩余的数字中最小(最大)浮到第二位 依次类推. 这种方法就像水泡上浮一样,顾名.
江源区19543924746: C语言:编写一个程序用冒泡排序实现升序排列 - ?
雷缸华仁: 1、首先打开一个空白的C语言文件,首先先定义一组待排序的数列以及各个变量,接着就是用来处理排序的逻辑: 2、冒泡排序的逻辑是一组数从第一个数值开始,如果相邻两个数的排列顺序与期望不同,则将两个数的位置进行交换,重复这样的过程直到最后一个数不需要交换则排序完成,如果有N个数需要排序,则需要进行(N-1)趟的比较: 3、最后编译运行程序,观察最终排序的结果,可以看到数字被从小到大的排列好了,以上就是C语言冒泡排序实现的过程:
江源区19543924746: C语言用冒泡法和选择法对10个数进行排序 - ?
雷缸华仁:[答案] 冒泡法: #define N 10 #include
江源区19543924746: C语言:编程实现从键盘上输入一组数据,用冒泡排序进行排序输出 - ?
雷缸华仁: 冒泡法:对10个数由大到小排序#include<stdio.h>#include<stdlib.h> main() { int i,j,a[11],m; for(i=1;i<11;i++) { scanf("%d",&a[i]); } for(j=1;j<=10;j++) { for(i=1;i<11-j;i++) { if(a[i+1]>a[i]) { m=a[i+1]; a[i+1]=a[i]; a[i]=m; } } } for(i=1;i<11;i++) { printf("%d ",a[i]); } system("pause"); } 希望能够帮到你!
江源区19543924746: C语言 写程序,冒泡排序法10个数升序排列. - ?
雷缸华仁: /* 冒泡法的基本思想就是:在待排序的数据中,先找到最小(大)的数据将它放到最前面, 再从第二个数据开始,找到第二小(大)的数据将它放到第二个位置,以此类推,直到只剩下最后一个数为止. 这种排序方法在排序的过程中, 是小的...