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

c语言冒泡排序法代码,为一个冒泡排序程序设计测试用例。并测试之（C语言编程）详细介绍

本文目录一览： c语言中冒泡法排序六个数

#include

int main()

{

int a[6],i,j;

printf("请输入6个数字:\n");

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

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

for(i=0;i<5;i++)//冒泡。

{

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

{

if(a[j]
<a[j+1])
{

int t=a[j];

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

a[j+1]=t;

}

}

}

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

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

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

printf("\n");

return 0;

}
</a[j+1])

C语言实现七种排序算法的演示代码是什么？

（1）“冒泡法” \x0d\x0a\x0d\x0a冒泡法大家都较熟悉。其原理为从a[0]开始，依次将其和后面的元素比较,若a[0]>a[i]，则交换它们，一直比较到a[n]。同理对a[1],a[2],...a[n-1]处理，即完成排序。下面列出其代码：\x0d\x0a\x0d\x0avoid bubble(int *a,int n) /*定义两个参数：数组首地址与数组大小*/ \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,temp; \x0d\x0a\x0d\x0afor(i=0;ia[j]) { \x0d\x0a\x0d\x0atemp=a[i]; \x0d\x0a\x0d\x0aa[i]=a[j]; \x0d\x0a\x0d\x0aa[j]=temp; \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a冒泡法原理简单，但其缺点是交换次数多，效率低。 \x0d\x0a\x0d\x0a下面介绍一种源自冒泡法但更有效率的方法“选择法”。 \x0d\x0a\x0d\x0a（2）“选择法” \x0d\x0a\x0d\x0a选择法循环过程与冒泡法一致，它还定义了记号k=i,然后依次把a[k]同后面元素比较，若a[k]>a[j],则使k=j.最后看看k=i是否还成立，不成立则交换a[k],a[i],这样就比冒泡法省下许多无用的交换，提高了效率。\x0d\x0a\x0d\x0avoid choise(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,k,temp; \x0d\x0a\x0d\x0afor(i=0;ia[j]) k=j; /*是k总是指向最小元素*/ \x0d\x0a\x0d\x0aif(i!=k) { /*当k!=i是才交换，否则a[i]即为最小*/ \x0d\x0a\x0d\x0atemp=a[i]; \x0d\x0a\x0d\x0aa[i]=a[k]; \x0d\x0a\x0d\x0aa[k]=temp; \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a选择法比冒泡法效率更高，但说到高效率，非“快速法”莫属，现在就让我们来了解它。 \x0d\x0a\x0d\x0a（3）“快速法” \x0d\x0a\x0d\x0a快速法定义了三个参数，（数组首地址*a,要排序数组起始元素下标i,要排序数组结束元素下标j). 它首先选一个数组元素（一般为a[(i+j)/2],即中间元素）作为参照，把比它小的元素放到它的左边，比它大的放在右边。然后运用递归，在将它左，右两个子数组排序，最后完成整个数组的排序。下面分析其代码：\x0d\x0a\x0d\x0avoid quick(int *a,int i,int j) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint m,n,temp; \x0d\x0a\x0d\x0aint k; \x0d\x0a\x0d\x0am=i; \x0d\x0a\x0d\x0an=j; \x0d\x0a\x0d\x0ak=a[(i+j)/2]; /*选取的参照*/ \x0d\x0a\x0d\x0ado { \x0d\x0a\x0d\x0awhile(a[m]k&&n>i) n--; /* 从右到左找比k小的元素*/ \x0d\x0a\x0d\x0aif(mi) quick(a,i,n); \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a（4）“插入法” \x0d\x0a\x0d\x0a插入法是一种比较直观的排序方法。它首先把数组头两个元素排好序，再依次把后面的元素插入适当的位置。把数组元素插完也就完成了排序。\x0d\x0a\x0d\x0avoid insert(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,temp; \x0d\x0a\x0d\x0afor(i=1;i=0&&temp=1)的那几个元素排好序，再缩小k值（一般取其一半），再排序，直到k=1时完成排序。下面让我们来分析其代码：\x0d\x0a\x0d\x0avoid shell(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i,j,k,x; \x0d\x0a\x0d\x0ak=n/2; /*间距值*/ \x0d\x0a\x0d\x0awhile(k>=1) { \x0d\x0a\x0d\x0afor(i=k;i=0&&x \x0d\x0a\x0d\x0a/*别偷懒，下面的"..."代表函数体，自己加上去哦！*/ \x0d\x0a\x0d\x0avoid bubble(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid choise(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid quick(int *a,int i,int j) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid insert(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0avoid shell(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0a... \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0a/*为了打印方便，我们写一个print吧。*/[code]\x0d\x0a\x0d\x0avoid print(int *a,int n) \x0d\x0a\x0d\x0a{ \x0d\x0a\x0d\x0aint i; \x0d\x0a\x0d\x0afor(i=0;i
<n;i++) \x0d\x0a\x0d\x0aprintf("%5d",a[i]); \x0d\x0a\x0d\x0aprintf("\n"); \x0d\x0a\x0d\x0a} \x0d\x0a\x0d\x0amain() \x0d\x0a\x0d\x0a{ *为了公平，我们给每个函数定义一个相同数组* \x0d\x0a\x0d\x0aint a1[]="{13,0,5,8,1,7,21,50,9,2};" a2[]="{13,0,5,8,1,7,21,50,9,2};" a3[]="{13,0,5,8,1,7,21,50,9,2};" a4[]="{13,0,5,8,1,7,21,50,9,2};" a5[]="{13,0,5,8,1,7,21,50,9,2};" \x0d\x0a\x0d\x0aprintf("the original list:"); \x0d\x0a\x0d\x0aprint(a1,10); \x0d\x0a\x0d\x0aprintf("according to bubble:"); \x0d\x0a\x0d\x0abubble(a1,10); choise:"); \x0d\x0a\x0d\x0achoise(a2,10); \x0d\x0a\x0d\x0aprint(a2,10); quick:"); \x0d\x0a\x0d\x0aquick(a3,0,9); \x0d\x0a\x0d\x0aprint(a3,10); insert:"); \x0d\x0a\x0d\x0ainsert(a4,10); \x0d\x0a\x0d\x0aprint(a4,10); shell:"); \x0d\x0a\x0d\x0ashell(a5,10); \x0d\x0a\x0d\x0aprint(a5,10); \x0d\x0a\x0d\x0a}

C语言冒泡排序法代码

程序如下：
# include

# include

int main(void){ int i, j, t,num; int * p; printf("请输入要排序的数的个数:num="); scanf("%d", &num); p= (int *)malloc(num* sizeof(int));//输入要排序的数 for (i=0; i
<num; ++i) { printf("请输入第%d个要排序的数p[%d]="\n"," i+1,i); scanf("%d", &p[i]); } 冒泡排序 for (i="0;" i<num-1; (j="0;" j
p[j+1]) // >表示升序
<表示降序 { t="p[j];" p[j]="p[j+1];" p[j+1]="t;" } 输出已经排序好的数printf("输出已经排序好的数"); for (i="0;" i<num; ++i) printf("%d ", p[i]); printf("\n"); return 0;}程序运行结果：
随机输入十个数：

楼上的诸位童鞋，你们能看全楼主的需求在回答问题吗？

1楼的代码没有满足要求中的第二条

3楼的代码没有满足要求中的第二条和提示中的第一条

4楼的代码单从面向对象的角度来说基本满足了“高内聚低耦合”但是你看楼主的需求了吗？所问非所答。。。

另外楼主是初学者，就得考虑环境变量是否配置正确

环境变量配置

用鼠标右击“我的电脑”->属性->高级->环境变量

系统变量->新建->变量名：JAVA_HOME 变量值：D:\Program Files\Java\jdk1.6.0_12(这只是我的JDK安装路径)

系统变量->编辑->变量名：Path 在变量值的最前面加上：%JAVA_HOME%\bin;（若已经有Path项，无须另外新建，直接在后

面加，但需用;与前面已有的项分隔开）

系统变量->新建->变量名：CLASSPATH 变量值：

.;%java_home%\lib\dt.jar;%java_home%\lib\tools.jar;%java_home%\jre\lib\rt.jar

1.配置无误后将如下代码保存名为MaoPaoSort.java的文件置于D盘根目录下（别忘了把你的名字班级学号加到代码中，我已注明替换位置）

2.在命令行中中进入D盘下

3.输入 javac MaoPaoSort.java 回车

4.输入 java MaoPaoSort 2 4 3 9 14 10 （数字参数可以随意输入个数，以空格分隔开）回车

5.输出排序结果以及本人的名字、班级和学号信息

如果上一步输入有误如 java MaoPaoSort 9 a B 之类运行后则显示错误提示信息

我在1楼代码的基础上做出了如下修正

public class MaoPaoSort {

public static void main(String[] args) {

try {

int mp[] = new int[args.length];

for (int i = 0; i < args.length; i++) {

mp[i] = Integer.parseInt(args[i]);

}

for (int i = 0; i < mp.length; i++) {

for (int j = 0; j < mp.length; j++) {

int temp;

if (mp[i] < mp[j]) {

temp = mp[j];

mp[j] = mp[i];

mp[i] = temp;

}

}

}

for (int i = 0; i < mp.length; i++) {

System.out.print(mp[i] + " ");

}

System.out.print("\n");

System.out.println("你的名字写在这里");

System.out.println("你的班级写在这里");

System.out.println("你的学号写在这里");

} catch (Exception e) {

System.out.println("没有传递参数或者参数类型不正确！请按照规则输入参数！程序退出...");

}

}

}

如果还有不明白的地方请继续追问，希望能对你有所帮助！

你好！很高兴能帮到你。

由于你刚学Java，所以一些编程规范是需要注意的，而我提供给你的答案看起来虽然有点复杂，不过采用了面向对象的编程思想，尽量做到低耦合高内聚，同时冒泡算法也做了升级，为冒泡的高级快速排序算法，不过为了对比，也保存了传统的冒泡算法。

需要讲解一下，算法本身不难，难在如何做到编程规范、以及方便修改、易于修改、使得程序灵活、低耦合高内聚。

算法部分请看Bubble类，里面有两种算法，有注释。

主类为TestBubble，主要用于调用Bubble对象运行算法、StuInfo对象提供学生作者信息、Info对象提供运行过程中提示信息。

运行结果如下（Bubble类为核心算法类）：

************************************

run：

请输入您将要输入整数的个数：

10

请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车

1:10

2:23

3:11

4:56

5:45

6:26

7:59

8:28

9:84

10:79

初始序列的数组为：

10 23 11 56 45 26 59 28 84 79

学号：200815009* 班级:08软件3班 姓名：叶科良

排序好的数组为：

10 11 23 26 28 45 56 59 79 84

源代码如下：

***************************************************

package testBubble;

import java.io.Reader;

import java.util.Scanner;

/**

*

* @author yekeliang

*/

public class TestBubble {

private CommandLineBubbleRunner commandLineBubbleRunner;

private int arraySize;

private int[] intArray;

private StuInfo stuInfo;

private Info info;

/**

* 测试方法

* @param args

*/

public static void main(String[] args) {

TestBubble test = new TestBubble();

}

/**

* 构造方法

* 调用初始化学生数据、接收命令行整数、展示结果3个成员方法

*/

public TestBubble() {

initMemb();

initData();

runBubble();

showResult(this.getIntArray());

}

/**

* 初始化学生数据

*/

private void initData() {

stuInfo.setStuNum("200815009*");

stuInfo.setStuClass("08软件3班");

stuInfo.setStuName("叶科良");

info.setInputIntNumInfo("请输入您将要输入整数的个数：");

info.setInputIntInfo("请输入一串数字进行冒泡排序，注意：每次只输入一个，输完则回车");

info.setShowInputInfo("初始序列的数组为：");

info.setShowResultInfo("排序好的数组为：");

info.setInputErrorInfo("对不起，输入有误！请输入整数.");

}

/**

* 接收命令行整数，使用冒泡算法

*/

private void runBubble() {

try{

System.out.println(info.getInputIntNumInfo());

setArraySize(getCommandLineBubbleRunner().getArraySize());

System.out.println(info.getInputIntInfo());

setIntArray(getCommandLineBubbleRunner().getAcceptAsIntArray(getArraySize()));

System.out.println(info.getShowInputInfo());

getCommandLineBubbleRunner().showAcceptAsIntArray(getIntArray());

Bubble.quick(getIntArray());

} catch(java.util.InputMismatchException e) {

System.out.println(info.getInputErrorInfo());

}

}

/**

* 展示结果

*/

private void showResult(int intArray[]) {

System.out.println("\n" + stuInfo.toString());

System.out.println(info.getShowResultInfo());

for (int i = 0; i < intArray.length; i++) {

System.out.print(intArray[i] + " ");

}

}

private void initMemb() {

stuInfo = new StuInfo();

info = new Info();

commandLineBubbleRunner = new CommandLineBubbleRunner();

}

public CommandLineBubbleRunner getCommandLineBubbleRunner() {

return commandLineBubbleRunner;

}

public void setCommandLineBubbleRunner(CommandLineBubbleRunner commandLineBubbleRunner) {

this.commandLineBubbleRunner = commandLineBubbleRunner;

}

public int getArraySize() {

return arraySize;

}

public void setArraySize(int arraySize) {

this.arraySize = arraySize;

}

public int[] getIntArray() {

return intArray;

}

public void setIntArray(int[] intArray) {

this.intArray = intArray;

}

private void getStuInfo() {}

}

/**

*

* @author 叶科良

*/

class CommandLineBubbleRunner {

public int num;//输入整数个数

/**

* 从命令行中读取需要输入的整数个数

* @return 需要输入的整数个数

*/

public int getArraySize() {

Scanner reader1 = new Scanner(System.in);

num = reader1.nextInt();

return num;

}

/**

* 指定数组大小，从命令行接收整数

* @param arraySize 数组大小

* @return 原始整数数组

*/

public int[] getAcceptAsIntArray(int arraySize) {

int[] acceptArray = new int[arraySize];

Scanner reader = new Scanner(System.in);

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

System.out.print((i + 1) + ":");

acceptArray[i] = reader.nextInt();

}

return acceptArray;

}

/**

* 打印原始输入数据

* @param intArray

*/

public void showAcceptAsIntArray(int[] intArray){

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

System.out.print(intArray[i] + " ");

}

}

/**

* 取得数组大小

* @return

*/

public int getNum() {

return num;

}

}

class Bubble {

/**

* 给定一个数组，使用冒泡算法进行排序

* @param acceptArray 给定的一个数组

* @return 排序好的数组

*/

public static int[] getResultAsIntArray(int[] acceptArray) {

int i, temp;

for (i = 0; i < (acceptArray.length - 1); i++) {//两两进行比较，符合条件的进行交换

if (acceptArray[i] > acceptArray[i + 1]) {

temp = acceptArray[i];

acceptArray[i] = acceptArray[i + 1];

acceptArray[i + 1] = temp;

}

}

return acceptArray;

}

/**

* 快速冒泡排序算法

* @param r 输入的整数数组

* @param first 数组第一个下标

* @param end 数组最后一个下标

* @return 排好序的整数数组

*/

public static int partition(int[] r, int first, int end) {

int i, j;

i = first;

j = end;

while (i < j) {

while (i < j && r[i] <= r[j]) {

j--;

}

if (i < j) {

int temp;

temp = r[i];

r[i] = r[j];

r[j] = temp;

}

}

return i;

}

public static void quick(int[] r, int first, int end) { //利用递归反复划分

if (first < end) {

int pivot = partition(r, first, end); //调用划分函数

quick(r, first, pivot - 1);

quick(r, pivot + 1, end);

}

}

public static int[] quick(int[] r){

quick(r,0,r.length-1);

return r;

}

}

class Info {

private String inputIntNumInfo;//提示用户输入整数个数的消息语句

private String inputIntInfo;//提示用户输入整数的消息语句

private String showInputInfo;//提示显示用户输入整数的消息语句

private String inputErrorInfo;//提示用户输入有误消息语句

private String showResultInfo;//提示显示排序结果

public String getInputIntNumInfo() {

return inputIntNumInfo;

}

public void setInputIntNumInfo(String inputIntNumInfo) {

this.inputIntNumInfo = inputIntNumInfo;

}

public String getInputIntInfo() {

return inputIntInfo;

}

public void setInputIntInfo(String inputIntInfo) {

this.inputIntInfo = inputIntInfo;

}

public String getShowInputInfo() {

return showInputInfo;

}

public void setShowInputInfo(String showInputInfo) {

this.showInputInfo = showInputInfo;

}

public String getInputErrorInfo() {

return inputErrorInfo;

}

public void setInputErrorInfo(String inputErrorInfo) {

this.inputErrorInfo = inputErrorInfo;

}

public String getShowResultInfo() {

return showResultInfo;

}

public void setShowResultInfo(String showResultInfo) {

this.showResultInfo = showResultInfo;

}

}

class StuInfo {

private String stuNum;//学生学号

private String stuName;//学生姓名

private String stuClass;//学生班级

@Override

public String toString() {

return "学号：" + getStuNum() + " 班级:" + getStuClass() + " 姓名：" + getStuName();

}

public String getStuNum() {

return stuNum;

}

public void setStuNum(String stuNum) {

this.stuNum = stuNum;

}

public String getStuName() {

return stuName;

}

public void setStuName(String stuName) {

this.stuName = stuName;

}

public String getStuClass() {

return stuClass;

}

public void setStuClass(String stuClass) {

this.stuClass = stuClass;

}

}

冒泡排序是排序算法的一种，思路清晰，代码简洁，常被用在大学生计算机课程中。“冒泡”这个名字的由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。这里以从小到大排序为例进行讲解。基本思想及举例说明

冒泡排序的基本思想就是不断比较相邻的两个数，让较大的元素不断地往后移。经过一轮比较就，选出最大的数；经过第2轮比较，就选出次大的数，以此类推。下面以对 3 2 4 1 进行冒泡排序说明。

1.这个算法用rand函数产生新的要排序的数据，与已有的有序数列中的数据依次比较，如果遇到比他大的数据，就从该数据开始，一直交换到末尾，达到一个插入的效果。从而形成有序的数列。

2.此外，只用rand函数并不能达到真正随机的效果。如果要实现真正随机的效果，还要配合srand函数才行。

3.具体代码如下：#include "stdio.h"#include "stdlib.h"void main(){int a[10],temp,r; printf("请输入一个种子\n"); scanf("%d",&r);srand(r); for(int i=0;i<9;i++) 。

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

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

C语言中选择排序法和冒泡排序法代码。

选择法的算法： 假设需要对10个数进行排序，那么首先找出10个数里面的最小数，并和这个10个数的第一个（下标0）交换位置，剩下9个数（这9个数都比刚才选出来那个数大），再选出这9个数中的最小的数，和第二个位置的数（下标1）交换，于是还剩8个数（这8个数都比刚才选出来的大）.. 依次类推，当还剩两个数时，选出两个数的最小者放在第9个位置（下标8），于是就只剩下一个数了。这个数已经在最后一位（下标9），不用再选择了。所以10个数排序，一共需要选择9次（n个数排序就需要选择n-1次）。#include "Stdio.h"void main(){ void sa(int array[],int n); int array[10],i; printf("enter the array:\n"); for(i=0;i<10;i++) scanf("%d",&array[i]); sa(array,10); printf("the sorted array:\n"); for(i=0;i<10;i++) printf("%d\t",array[i]); getch();}void sa(int array[],int n){ int i,j,k,temp; for(i=0;i<10;i++) { k=i; for(j=i+1;j
<n;j++) if(array[j]<array[k]) k="j;" temp="array[k];" array[k]="array[i];" array[i]="temp;" }}
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
=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趟扫描。 ③改进不对称性的方法 在排序过程中交替改变扫描方向，可改进不对称性。
勤奋一点网上都可找到，这是帮你拷的。祝你进步！

选择排序：

void select_sort(int a[],int n) //传入数组的要排序的元素个数

{int i,j,min,t;

for(i=0;i
<n-1;i++)
{ min=i; //min:当前最小值下标

for(j=i+1;j
<n;j++) 扫描余下的部分
if(a[min]>a[j]) //若有其它元素更小，就记录其下标

min=j;

if(min!=i) //保若最小值不在排序区首位，就换到首位

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

}

}

冒泡排序：

void bubble_sort(int a[], int n) //传入数组的要排序的元素个数

{ int i, j, t;

for (j=0; j
<n-1; j++) n个元素比较n-1轮
for (i= 0; i
<n-1-j;i++) 比较相信的两个数
if(a[i]>a[i+1]) //若大小顺序不符，就交换

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

}

</n-1;i++)

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语言编程）

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;

}

```

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

C语言：采用冒泡排序方法,对10个数按由小到大的的顺序排序

代码如下（对10个整数进行升序排序）：
#include

int main()

{

int i,j,t,a[10]={5,4,8,3,6,9,7,222,64,88};

//排序

for(i=1;i<10;i++)//外循环控制排序趟数，n个数排n-1趟

{

for(j=0;j<10-1;j++)//内循环每趟比较的次数，第j趟比较n-i次

{

if(a[j]>a[j+1])//相邻元素比较，逆序则交换

{

t=a[j];

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

a[j+1]=t;

}

}

}

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

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

{

printf("%d",a
);
}
printf("\n");
return 0;
}
冒泡法：
算法分析：如果有n个数，则要进行n-1趟比较。在第1趟比较中要进行n-1次相邻元素的两两比较，在第j趟比较中要进行n-j次两两比较。比较的顺序从前往后，经过一趟比较后，将最值沉底（换到最后一个元素位置），最大值沉底为升序，最小值沉底为降序。
扩展资料：include用法：
#include命令预处理命令的一种，预处理命令可以将别的源代码内容插入到所指定的位置；可以标识出只有在特定条件下才会被编译的某一段程序代码；可以定义类似标识符功能的宏，在编译时，预处理器会用别的文本取代该宏。
插入头文件的内容
#include命令告诉预处理器将指定头文件的内容插入到预处理器命令的相应位置。有两种方式可以指定插入头文件：
1、#include

C语言：编写一个程序用冒泡排序实现升序排列