关于冒泡排序！急！！！

冒泡排序算法~

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到最大数前的一对相邻数，将小数放前，大数放后，第二趟结束，在倒数第二个数中得到一个新的最大数。如此下去，直至最终完成排序。
由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复 9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i, j的值依次为1,2,...10-i。
产生
在许多程序设计中，我们需要将一个数列进行排序，以方便统计，而冒泡排序一直由于其简洁的思想方法而倍受青睐。
排序过程
设想被排序的数组R〔1..N〕垂直竖立，将每个数据元素看作有重量的气泡，根据轻气泡不能在重气泡之下的原则，从下往上扫描数组R，凡扫描到违反本原则的轻气泡，就使其向上"漂浮"，如此反复进行，直至最后任何两个气泡都是轻者在上，重者在下为止。
算法示例
49 13 13 13 13 13 13 13
38 49 27 27 27 27 27 27
65 38 49 38 38 38 38 38
97 65 38 49 49 49 49 49
76 97 65 49 49 49 49 49
13 76 97 65 65 65 65 65
27 27 76 97 76 76 76 76
49 49 49 76 97 97 97 97
Procedure BubbleSort(Var R : FileType) //从下往上扫描的起泡排序//
Begin
For I := 1 To N-1 Do //做N-1趟排序//
begin
NoSwap := True; //置未排序的标志//
For J := N - 1 DownTo 1 Do //从底部往上扫描//
begin
If R[J+1]< R[J] Then //交换元素//
begin
Temp := R[J+1]; R[J+1 := R[J]; R[J] := Temp;
NoSwap := False
end;
end;
If NoSwap Then Return//本趟排序中未发生交换，则终止算法//
end
End; //BubbleSort//
该算法的时间复杂性为O(n^2),算法为稳定的排序方
编辑本段
冒泡排序代码
AAuto
bubble_sort = function(array){
var temp;
for( i=1;#array ){
//i前面的已经是最小的数，并排序好了
for(j=#array;i+1;-1){
//挨个比较
if(array[j]<array[j-1]){
//小的总是往前排
bubble = array[j]
array[j] = array[j-1];
array[j-1] = bubble;
}
}
}
}
io.print("----------------")
io.print("冒泡排序( 交换类换排序 )")
io.print("----------------")
array ={2;46;5;17;1;2;3;99;12;56;66;21};
bubble_sort(array,1,#array)
//输出结果
for(i=1;#array;1){
io.print( array[i] )
}
C
void bubble_sort(int *x, int n)
{
int j, k, h, t;
for (h=n-1; h>0; h=k) /*循环到没有比较范围*/
{
for (j=0, k=0; j<h; j++) /*每次预置k=0，循环扫描后更新k*/
{
if (*(x+j) > *(x+j+1)) /*大的放在后面，小的放到前面*/
{
t = *(x+j);
*(x+j) = *(x+j+1);
*(x+j+1) = t; /*完成交换*/
k = j; /*保存最后下沉的位置。这样k后面的都是排序排好了的。*/
}
}
}
}
C++
#include
#define LEN 9
using namespace std;
int main()
{
int nArray[LEN];
for(int i=0;i<LEN;i++)nArray[i]=LEN-i;
cout<<"原始数据为："<<endl;
for(int i=0;i<LEN;i++)cout<<nArray[i]<<" ";
cout<<endl;
//开始冒泡
{
int temp;
for(int i=LEN-1;i>0;i--)
for(int j=0;j<i;j++)
{
if(nArray[j]>nArray[j+1])
{
temp=nArray[j];
nArray[j]=nArray[j+1];
nArray[j+1]=temp;
}
}
}
//结束冒泡
cout<<"排序结果:"<<endl;
for(int i=0;i<LEN;i++)cout<<nArray[i]<<" ";
return 0;
}

这是选择排序，不是冒泡排序的呀。它们的相同之处在于，每趟都是得到无序区中的最小元，并将其放到无序区的开始。但它们得到最小元的方法是不同的。冒泡排序通常是从后向前扫描，然后最小元从后一步一步慢慢移到无序区的前面，而选择排序则是从前向后快速扫描一趟，扫描过程中一般不做数据的移动，只是先定位最小元的位置，然后将最小元直接和首元进行交换。在一趟冒泡过程中，最坏的情况下将有n次交换（n为无序区元素的个数），而进行一趟选择时，最坏情况下也只需要一次交换即可。

这样不更简单：
import java.util.Arrays;
public class test111 {
public static void main(String[] args) {
int[] a = { 5, 9, 7, 1 };
Arrays.sort(a);
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}

}
}

你这个问题 就是J应该初值应该是0不是1
public class test111 {
public static void main(String[] args) {
int[] a = { 5, 9, 7, 1 };

int temp;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length - i - 1; j++) {
if (a[j] > a[j + 1]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}

}
}

//我给你改了
public class Work11111 {
public static void main(String[] args) {
int[] a = {5,9,7,1};

int temp;
for (int i = 0; i < a.length; i++) {
for (int j = 0; j < a.length-1 ; j++) {
if(a[j] > a[j+1]){
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;

}

}
}
for (int i = 0; i < a.length; i++) {
System.out.print(a[i]);
}

}

}

---

秀峰区15092389963： 冒泡排序是如何实现的? ？
戚钱力复： 排序算法冒泡排序冒泡排序是这样实现的:1、从列表的第一个数字到倒数第二个数字,逐个检查:若某一位上的数字大于他的下一位,则将它与它的下一位交换

秀峰区15092389963： C语言用冒泡法输入一个字符升序排列 急! - ？
戚钱力复： #include <iostream.h>#include <string.h>#include <stdio.h>#include <stdlib.h>/* 冒泡排序法 */ void Bublesort(char a[],int n) { int i,j; char k; for(j=0;j<n;j++) /* 气泡法要排序n次*/ { for(i=0;i<n-j;i++) /* 值比较大的元素沉下去后,只把剩下的元素中的...

秀峰区15092389963： 急!!!!用指针冒泡排序 - ？
戚钱力复： #include<stdio.h> void scan(int *p,int k) { int i; printf(＂input the number:\n＂); for(i=0;i<k;i++) { scanf(＂%d＂,p+i); } } void print(int *p,int k) { int i; printf(＂the sprted number:\n＂); for(i=0;i<k;i++) printf(＂%d ＂,*(p+i)); printf(＂\n＂); } void insert(int *p,...

秀峰区15092389963： 急!急!!冒泡法排序过程 - ？
戚钱力复： 第一趟:89 21 56 48 85 16 19 4721 89 56 48 85 16 19 4721 56 89 48 85 16 19 4721 56 48 89 85 16 19 4721 56 48 85 89 16 19 4721 56 48 85 16 89 19 4721 56 48 85 16 19 89 4721 56 48 85 16 19 47 89第二趟:21 56 48 85 16 19 47 8921 48...

秀峰区15092389963： 冒泡排序是什么? ？
戚钱力复： 冒泡排序算法分析编辑冒泡排序时间复杂度若文件的初始状态是正序的,一趟扫描即可完成排序

秀峰区15092389963： 急!!C语言冒泡排序编程 - ？
戚钱力复： #include <stdio.h> #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<count;i++) { for(int j=i + 1;j<count; j++) { compareCount++; if(array[i] > array[j])...

秀峰区15092389963： 关于C语言冒泡排序法要详解 - ？
戚钱力复： #include void main(){int a[10]={8,9,1,6,4,2,7,3,5};int i,j,k;//for(i=0;i<8;i++)for(j=0;j<10;j++){ if(a[j]>a[j+1]){k=a[j];a[j]=a[j+1];a[j+1]=k;...

秀峰区15092389963： 冒泡排序流程图 - ？
戚钱力复： 冒泡第一次:14 15 28 5 10 30 冒泡第二次:14 15 5 10 28 30 冒泡第三次:14 5 10 15 28 30 冒泡第四次:5 10 14 15 28 30选择排序我忘记了!

秀峰区15092389963： 急!!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] ...

秀峰区15092389963： 什么是冒泡程序啊它是做什么的<br/>请高手指点一下 ？
戚钱力复： 所谓冒泡排序,形象的说,就是在将一组数据从小到大的顺序排列时,小的数据视为质量较轻,大的数据视为质量较重,小的数据好比水中的气泡,往上方移动,较大的数据好比是石头,往下沉,最重的会沉到底,最轻的会浮到顶,反复进行比较,直到数据列排成有序列.它的基本特征是将最大数排到了最右边,然后再从头开始,进行第二次排序,将第二大的数据排到了倒数第二位,反复下去,就可以完成排序.