冒泡法排序c语言程序,C语言冒泡排序法将学生成绩按从小到大顺序排列

冒泡法排序c语言程序,C语言冒泡排序法将学生成绩按从小到大顺序排列详细介绍

本文目录一览： c语言冒泡排序法

#include

int main()

{

int a[10];

int i,j,t,temp;

printf("请输入10个数:");

for (i=0;i<10;i++) //输入10个待排序的数

{

scanf("%d",&a[i]);

}

for (j=1;j<=9;j++) //j从1到10循环

{

t=10-j; //t=10-j

for (i=0;i
<t;i++) i从0到t-1循环 比较相邻的元素。如果第一个比第二个大，就交换他们两个

{

if (a[i]>a[i+1])

{

temp=a[i];

a[i]=a[i+1];

a[i+1]=temp;

}

}

}

for (i=0;i<=9;i++) //输出排序后的数字

{

printf("%d\t",a[i]);

}

return 0;

}

第一次循环j=0 t=9 里循环i从0到9将最大的数换到a[9];

因为a[9]已经是最大 接下来第二次循环 j=1 t=8 将剩下9个数中最大的换到a[8]以此类推到最后一个数。

上面那个循环嵌套完成的就是下面的过程

冒泡排序算法的运作如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。

对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

针对所有的元素重复以上的步骤，除了最后一个。

持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

（1）基本思想：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

（2）实例：

（3）代码解释：

#include

int main(){int a[10];int i,j,t,temp;//temp记录临时中间值printf("请输入10个数:");for (i=0;i<10;i++){scanf("%d",&a[i]);//记录输入的十个数}for (j=1;j<=9;j++){t=10-j;for (i=0;i

a[i+1]) {

// 交换两数的位置

temp=a[i];a[i]=a[i+1];a[i+1]=temp;}}

}for (i=0;i<=9;i++){printf("%d\t",a[i]);}return 0;}

望采纳！

用C语言编程：用“冒泡法”对输入的10个字符按由小到大的顺序排列。

#include "stdio.h"
#include "stdlib.h"
void Bubble(float a[]){
int i,j;
float temp;
for(i=0;i<9;i++)
for(j=0;j<9-i;j++)
{
if(a[j]>a[j+1])
{temp = a[j]; a[j] = a[j+1]; a[j+1] = temp;}
}
}
main()
{
float B[10],average=0,sum=0;
int i,j=0;
for(i=0;i<10;i++)
scanf("%f",&B[i]);
for(i=0;i<10;i++)
sum+=B[i];
average = sum/10.0;
printf("average = %.2f\n",average);
Bubble(B);
for(i=9;i>=0;i--)
{
printf("%.2f\t",B[i]);
++j;
if(j==5)
printf("\n");
}
system("pause");
}
多送你个求平均数
这是我们期末考试的题目
冒泡法就是将最大的数找到排到后面去
课本上有啊！看书去吧！
1、打开Visual stdio 2019软件新建空白c文件，在源文件处右击鼠标，选择添加下面的新建项，此时会弹出窗口：
2、弹出的窗口选择C++文件，将文件扩展名改为“.c”点击添加完成新建c文件，之后就可以编写程序了：
3、接下来就可以编写程序了，首先最前面的部分为输入数字的部分，之后的程序会对用户输入的数字就行排序，最后则是将结果打印出来。冒泡排序需要用到两层循环，第一层循环遍历数组中的元素，第二层则进行两两比较，如果顺序不对就要对其进行换位，直到排序完成：
4、最后执行程序观察结果，按下crtl+F5弹出程序，随意输入10个数，按下回车键执行结果，此时就可以看到排序后的结果了。以上就是c语言冒泡排序程序的演示：

为一个冒泡排序程序设计测试用例。并测试之（C语言编程）

static void Main(string[] args)
{

int [] arrarys={12,78,89,45,56,263,15,05,26,35};
for (int i = 0; i < arrarys.Length; i++)
{
for (int j = 0; j < i; j++)
{
if(arrarys[i]>arrarys[j])
{
int emp = 0;
emp = arrarys[i];
arrarys[i] = arrarys[j];
arrarys[j] = emp;
}
}
}
foreach (int arr in arrarys)
{
Console.Write(arr);
Console.WriteLine();
}
Console.ReadKey();
}
#include"stdio.h"
main()
{
int a[10],i,j,k;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
for(j=0;j<100;j++)
for(i=0;i<9;i++)
if(a[i]>a[i+1])
{k=a[i];a[i]=a[i+1];a[i+1]=k;}
for(i=0;i<10;i++)
printf("%d ",a[i]);
}
以下是一个冒泡排序程序的示例代码，它可以对输入的任意数量整数进行排序：
```c
#include

void bubble_sort(int list[], int n) {

int i, j, temp;

for(i = 0; i < n-1; i++) {

for(j = 0; j < n-i-1; j++) {

if(list[j] > list[j+1]) {

temp = list[j];

list[j] = list[j+1];

list[j+1] = temp;

}

}

}

}

int main() {

int n, i;

printf("请输入要排序的整数个数：");

scanf("%d", &n);

int list[n];

printf("请输入%d个整数：", n);

for(i = 0; i < n; i++) {

scanf("%d", &list[i]);

}

bubble_sort(list, n);

printf("排序后的结果是：");

for(i = 0; i < n; i++) {

printf("%d ", list[i]);

}

return 0;

}

```

接下来是测试用例，包括了多种情况，以验证算法在各种情况下的正常工作：

```c

#include

int main() {

// 测试用例1：对3个整数进行排序

int list1[] = {2, 1, 3};

bubble_sort(list1, 3);

printf("测试用例1：[2, 1, 3] -> [1, 2, 3]

");

for(int i = 0; i < 3; i++) {

printf("%d ", list1[i]);

}

printf("

");

// 测试用例2：对10个整数进行排序

int list2[] = {56, 89, 17, 21, 2, 76, 12, 9, 47, 62};

bubble_sort(list2, 10);

printf("测试用例2：[56, 89, 17, 21, 2, 76, 12, 9, 47, 62] -> [2, 9, 12, 17, 21, 47, 56, 62, 76, 89]

");

for(int i = 0; i < 10; i++) {

printf("%d ", list2[i]);

}

printf("

");

// 测试用例3：对1个整数进行排序

int list3[] = {5};

bubble_sort(list3, 1);

printf("测试用例3：[5] -> [5]

");

for(int i = 0; i < 1; i++) {

printf("%d ", list3[i]);

}

printf("

");

return 0;

}

```

测试结果显示，算法可以正常地对数组进行排序。

1． 编写冒泡排序和选择排序的程序，主函数中编写菜单调用排序函数。C语言

a0003:
push cx
push si
a0002:
mov dl,A[si]
cmp dl,A[si+1]
jb a0001
xchg dl,A[si+1]
xchg A[si],dl
a0001: inc si
loop a0002
pop si
pop cx
loop a0003

mov ah,4ch
int 21h
code ends
end start
#include "stdio.h"
#define N 10
main()
{
int a[N],i,j;
for(i=0;i
<n;i++)
scanf("%d",&a[i]);

for(i=0;i
<n;i++)
for(j=i+1;j
<n-1;j++)
if(a[i]>a[j])

{t=a[i];a[i]=a[j];a[j]=t;}

for(i=0;i
<n;i++)
printf(" %d",a[i]);

}

void sort_xuanze(int a[],int n)

{int i,j,t;

for(i=0;i
<n-1;i++)
for(j=i+1;j
<n;j++)
if(a[i]>a[j]){t=a[i];a[i]=a[j];a[j]=t; } /*升序排序 */

}

void sort_maopao(int a[],int n)

{int i,j,t;

for(i=0;i
<n-1;i++)
for(j=0;j
<n-i-1;j++)
if(a[j]>a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t; } /*升序排序 */

}

main()

{int a[10],i;

for(i=0;i
<n;i++)
scanf("%d",&a[i]);

sort_xuanze(a,10); /*调用*/

for(i=0;i
<n;i++)
printf("%5d",a[i]);

printf("\n");

sort_maopao(a,10); /*调用*/

for(i=0;i
<n;i++)
printf("%5d",a[i]);

printf("\n");

}

//C语言示例代码如下#include

#define N 10//冒泡排序(升序)void bubble_sort(int a[],int n){ int i,j; //j表示趟数,i表示第j趟两两比较的次数 int tmp; //临时变量 for(i=0;i
<n-1;i++) for(j="0;j
a[j+1]) { tmp=a[j]; a[j]=a[j+1]; a[j+1]=tmp; } }}//选择排序算法，按从小到大顺序void select_sort(int *array,int n){ int i,j,k; int tmp; for(i=0;i
<n-1;i++) { k="i;" 开始一趟选择排序，假定第i个元素是后面n-i+1个未排序的元素中最小的元素 for(j="i+1;j
array[j]) //如果发现比当前最小元素还小的元素，则更新记录最小元素的下标k k=j; } //如果最小元素的下标不是后面n-i+1的未排序序列的第一个元素,则需要交换第i个元素和后面找到的最小元素的位置 if(k != i) { tmp=array[k]; array[k]=array[i]; array[i]=tmp; } }}int main(){ int arr[N]; int i; printf("输入数组元素: "); for(i=0;i
<n;i++) scanf("%d",&arr[i]); bubble_sort(arr,n); 调用冒泡排序函数 printf("输出排序后的数组元素: "); for(i="0;i<N;i++)" printf("%d ",arr[i]); printf("\n输入数组元素: select_sort(arr,n); 调用选择排序函数 printf("\n"); return 0;}

</n;i++)
</n;i++)
</n;i++)
</n-i-1;j++)
</n-1;i++)
</n;j++)
</n-1;i++)

</n-1;j++)
</n;i++)

c语言冒泡排序的编程

#include

void sort(int *a,int len){int i=0;int j;int t;for(i=0;i
<len-1;i++) {for(j="0;j
a[j+1]){t=a[j];a[j]=a[j+1];a[j+1]=t;}}}}int main(int argc, char *argv[]){int a[10]={-999,2,3,77,12,88,0,-8,99,100};int i=0;sort(a,10);for(i=0;i<10;i++){printf(%d ,a[i]);}return 0;}冒泡算法冒泡排序的算法分析与改进 交换排序的基本思想是：两两比较待排序记录的关键字，发现两个记录的次序相反时即进行交换，直到没有反序的记录为止。 应用交换排序基本思想的主要排序方法有：冒泡排序和快速排序。冒泡排序 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
=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(外循环) bubblesort4、算法分析 （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趟扫描。 ③改进不对称性的方法 在排序过程中交替改变扫描方向，可改进不对称性。

C语言：编写函数，用冒泡法对一组数按从小到大的顺序进行3轮排序？

#include "stdio.h"
void fun(int a[],int n)
{ int i,j,t;
for(i=0; i<3; i++)
for(j=0; j
<n-1-i; j++)
if(a[j]>a[j+1])

{ t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

}

main()

{ int a[10],i;

for(i=0; i<10; i++)

scanf("%d",&a[i]);

fun(a,10);

for(i=0; i<10; i++)

printf("%5d",a[i]);

printf("\n");

}

C语言冒泡排序法

#include

void main()

{

int a[10];

int i,j,t;

printf("input 10 numbers:\n");

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:\n");

for(i=0;i<10;i++)

printf(" %d",a[i]);

}

扩展资料：冒泡排序算法的运作

1、比较相邻的元素。如果第一个比第二个大（小），就交换他们两个。

2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大（小）的数。

3、针对所有的元素重复以上的步骤，除了最后已经选出的元素（有序）。

4、持续每次对越来越少的元素（无序元素）重复上面的步骤，直到没有任何一对数字需要比较，则序列最终有序。

简单的表示

#include

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\n", 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

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\n",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语言冒泡排序的编程为：

#include

void sort(int *a,int len)

{int i=0;

int j;

int t;

for(i=0;i
<len-1;i++)[1]
{

for(j=0;j
<len-i-1;j++)
{

if(a[j]>a[j+1])

{

t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

}

}

}

int main(int argc, char *argv[])

{

int a[10]={

-999,2,3,77,12,88,0,-8,99,100

};

int i=0;

sort(a,10);

for(i=0;i<10;i++)

{

printf("%d ",a[i]);

}

return 0;

}

这是每次遍历的时候最小值就会移到最低位

最多进行n-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

到此第一趟排序结束，接下来的每一趟排序都是这样。

#include

void Print(int *num, int n){ int i; for(i = 0; i < n; i++) printf("%d ", num[i]); puts("\n"); 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;}

</len-i-1;j++)

C语言冒泡法排序：任意输入十个数排序（从小到大；从大到小）

从小到大
#include

void main()

{

int a[10];

int i,j,t;

printf("please enter 10 number:\n");

for(j=0;j<10;j++)

scanf("%d",&a[j]);

printf("\n");

for(i=0;i<9;i++)

for(j=0;j<9-i;j++)

if(a[j]>a[j+1])//把>改成
<就是从小到大
{

t=a[j];

a[j]=a[j+1];

a[j+1]=t;

}

for(j=0;j<10;j++)

printf("%d",a[j]);

printf("\n");

}

从大到小：

#include

#define N 10

void main()

{

int i,j;

float a[N],t;

printf("排序前:\n");

for(i=0;i
<n;i++)
{

scanf("%d",&a[i]);

}

for(i=0;i
<n;i++)
{

printf("%6.1f",a[i]);

}

printf("\n");

for(i=0;i
<n-1;i++)
{

for(j=0;j
<n-i-1;j++)
if(a[j]
<a[j+1])
{

t=a[j]; a[j]=a[j+1]; a[j+1]=t;

}

}

printf("排序后:\n");

for(i=0;i
<n;i++)
printf("%6.1f",a[i]);

printf("\n");

}

从小到大：if(a[j]

a[j+1])

即

#include

</n;i++)
</a[j+1])
</n-i-1;j++)
</n-1;i++)
</n;i++)
</n;i++)

</就是从小到大

C语言冒泡排序法将学生成绩按从小到大顺序排列

#include

struct student{ char name[20]; char sex[20]; int age; int score;};void sort(struct student data[], int size){ /*冒泡排序*/ int x,y; struct student temp; for(x=0;x
<size-1;x++) for(y="0;y
data[y+1].score) { temp=data[y+1]; data[y+1]=data[y]; data[y]=temp; } }int main(){ int qty, counter; struct student data[1000]; scanf("%d",&qty); for(counter=0;counter
<qty;++counter) scanf("%s%s%d%d",data[counter].name,data[counter].sex,&data[counter].age,&data[counter].score); sort(data,qty); for(counter="0;counter<qty;++counter)" printf("%s %s %d %d\n",data[counter].name,data[counter].sex,data[counter].age,data[counter].score); return 0;}

C语言冒泡排序（数组）

按照你的要求编写的C语言冒泡排序的程序如下
#include

int main(){ int i,j,k,T,n,tmp; scanf("%d",&T); for(i=0;i
<t;i++){ scanf("%d",&n); int a[n]; for(j="0;j<n-1;j++){" scanf("%d",&a[j]); } for(k="0;k
a[k+1]){ tmp=a[k]; a[k]=a[k+1]; a[k+1]=tmp; } } for(k=0;k
<n;k++){ printf("%d ",a[k]); } printf("\n"); return 0;}运行结果输入 2输入 5 10 4 43 1 2输出 2 434 431 43输入 20 123 12 54 45 23 -10输出20 -10 43412 4342 434-10 434