C语言冒泡排序法代码

C语言 冒泡排序法的代码~

#include
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

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;
}
参考资料来源：冒泡排序-百度百科

#include
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

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;
}
参考资料来源：冒泡排序-百度百科

冒泡排序每一趟排序把最大的放在最右边。

比如：

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 <malloc.h>
# include <stdio.h>
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]=
", i+1,i);
		scanf("%d", &p[i]);
	}

//冒泡排序
	for (i=0; i<num-1; ++i)
	{
		for (j=0; j<num-1-i; ++j)
		{
			if (p[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("
");

	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 进行冒泡排序说明。

---

山阳区19292805119： c语言用冒泡法选择法从键盘任意输入十个小写字母,按从大到小的顺序排序输出. - ？
蓍宗低分： 1 输入; 2 排序; 3 输出. 参考代码如下: #include <stdio.h> int main() {int a[10];//用来存数据int i,j,temp; for(i = 0; i < 10; i ++)//输入10个数.scanf(＂%d＂,&a[i]);for (j = 0; j < 9; j++)//标准冒泡法排序for (i = 0; i < 9- j; i++){if(a[i] > a[i + ...

山阳区19292805119： 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＂); } 希望能够帮到你!

山阳区19292805119： 冒泡排序法实现代码在哪里 - ？
蓍宗低分： C语言为:#includevoid main() { int a[10]; int i,j,t; printf(＂输入10个整数:\n＂); for( i = 0; i < 10; i ++ ) scanf(＂%d＂,&a[ i ]); //依次输入10个整数 for( j = 0; j < 9; j ++ ) //进行9轮排序 即n-1次 { for( i = 0; i < 9-j; i ++) //每轮进行n-1-j 次比较,最...

山阳区19292805119： 求一例简单C语言编写的冒泡程序.. - ？
蓍宗低分： 冒泡排序详细注释: /* 用冒泡排序法对一维整型数组中的十个数升序排序 */ #include <stdio.h> #include <stdlib.h>int main() { int i,j,t,a[10]; printf(＂Please input 10 integers:\n＂); for(i=0;i<10;i++) scanf(＂%d＂,&a[i]); for(i=0;i<9;i++) /* 冒泡法排序...

山阳区19292805119： C语言:编写一个程序用冒泡排序实现升序排列 - ？
蓍宗低分： 1、首先打开一个空白的C语言文件,首先先定义一组待排序的数列以及各个变量,接着就是用来处理排序的逻辑: 2、冒泡排序的逻辑是一组数从第一个数值开始,如果相邻两个数的排列顺序与期望不同,则将两个数的位置进行交换,重复这样的过程直到最后一个数不需要交换则排序完成,如果有N个数需要排序,则需要进行(N-1)趟的比较: 3、最后编译运行程序,观察最终排序的结果,可以看到数字被从小到大的排列好了,以上就是C语言冒泡排序实现的过程:

山阳区19292805119： 用C语言编写函数,要实现快速排序算法或者冒泡法 - ？
蓍宗低分： 冒泡法排序函数如下: void bubble(int a[],int n) {int i,j,t;for(i=0;i<n-1;i++)/*共进行n-1轮*/for(j=0;j<n-1-i;j++)/*每轮在前n-i个数中比较*/if(a[j]>a[j+1]) /*若相邻元素逆序*/ {t=a[j]; a[j]=a[j+1];a[j+1]=t;}/*就交换*/ }void sort(int *a, int left, int right) {if(...

山阳区19292805119： 求C语言冒泡法代码,谢谢! - ？
蓍宗低分： 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＂); }

山阳区19292805119： C语言冒泡排序？
蓍宗低分： #include<stdio.h> void main() {int a [10],i,j,t;for(i=0;i<10;i++)scanf(＂%d＂,&a[i]);for (j=0;j<9;j++)for (i=0;i<9-j;i++)if(a[i]>a[i+1]){ t=a[i];a[i]=a[i+1];a[i+1]=t; } for (i=0;i<10;i++)printf(＂%d ＂,a[i]); }

山阳区19292805119： C语言冒泡排序法是怎么排序的? - ？
蓍宗低分： C语言冒泡排序法的排2113序规则:5261将被排序的记录4102数组R[1..n]垂直排列,每个记录R看作是重量为R.key的气泡1653.根据轻气泡不能在重气泡之下的原则,从下往上扫描数组R:凡扫描到违反本原则的轻气泡,就使其向上＂飘浮＂...

山阳区19292805119： 急!!C语言冒泡排序编程？
蓍宗低分： #include &lt;stdio.h&gt; #define MAX_ROW 15 #define MAX_COLUMN 10 void sort(int array[], int count, int arrayIndex) { int compareCount = 0; int moveCount = 0; for(int i=0; i&lt;count;i++) { for(int j=i + 1;j&lt;count; j++) { compareCount++; if(array[i] ...