求教冒泡排序

[qiongfengcai]

为什么我每次见到的冒泡排序都是不一样的呢？？？
　
并且我在看冒泡的时候老是看得乱乱的。。

有没有谁给个比较简单易懂好记的冒泡排序呢？？

谢谢。。。。

[timeriver_wang]

[Quote=引用 34 楼 zhangshan5588 的回复:]
最简单是还是一楼的 lz理解就好了
[/Quote]
一楼的不是冒泡排序，是插入排序，
这4中排序要比较才能区分开啊

[WuBill]

外层从后往前
里层从前往后
[code=Java]
public void bubbleSort(int[] data){
for(int out=data.length-1; out>1; out--){
for(int in=0; in<out; in++){
if( a[in] > a[in+1] ){
int temp = data[in];
data[in] = data[in+1];
a[in] = temp;
}
}
}
}

[pywepe]

lz切记呀 要懂原理

冒泡 冒泡就是把大的沉下去 或都 小的沉下去

过种无非就是
ps:这里说大的沉下去的情况

第一个数跟第二个数比 要是第一个比第二个大交换一个位置

然后第二个数跟第三个数比 注意的是这里的第二个数 是经过上面这个过程的数了

...

以些类推

这样就是10个数
外层循环10次
内层循环从10-1次开始递减

[itolddd9720]

支持楼上的，要懂得原理，问题就简单了。

[Allsochen]

本人建议用Eclipse中的DEBUG来看整个数组的变化过程，这样对你理解冒泡排序很有帮助。

[jacksonlai]

回答得相当踊跃啊！！

[haojia0716]

[Quote=引用 37 楼 wnjok 的回复:]
引用 34 楼 zhangshan5588 的回复:
最简单是还是一楼的 lz理解就好了

一楼的不是冒泡排序，是插入排序，
这4中排序要比较才能区分开啊
[/Quote]

    public static void sort(int[] data) {
        for (int i = 0; i < data.length; i++) {
            System.out.println(Arrays.toString(data));
            for (int j = i + 1; j < data.length; j++) {
                if (data[i] > data[j]) {
                    int temp = data[i];
                    data[i] = data[j];
                    data[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(data));
    }

那请问这是什么排序

[cs0301lm]

我的ups算的这么慢 55555555
冒泡排序开始时间：2009-09-15 13:05:29.057
冒泡排序结束时间：2009-09-15 13:06:22.031
长度为100000的数组冒泡排序耗时52974ms!

---------------
选择排序开始时间：2009-09-15 13:06:22.031
选择排序结束时间：2009-09-15 13:06:53.927
长度为100000的数组选择排序耗时31896ms!

---------------
插入排序开始时间：2009-09-15 13:06:53.927
插入排序结束时间：2009-09-15 13:07:21.827
长度为100000的数组插入排序耗时27900ms!

---------------
快速排序开始时间：2009-09-15 13:07:21.827
快速排序结束时间：2009-09-15 13:07:21.874
长度为100000的数组快速排序耗时47ms!


[Quote=引用 33 楼 wnjok 的回复:]
兄弟，你准备面试的吧？
我对：冒泡，选择，插入，快速4种排序做了对比，希望对你有帮助！

Java codeimport java.sql.Timestamp;import java.util.Arrays;import java.util.Random;publicclass Sort {staticint NUM=100000;staticlong start;//开始时间staticlong end;//结束时间publicstaticvoid main(String[] args) {//生成3个相同的数组，同一情况下比较 Random random=new Random();int[]a1=newint[NUM];for(int i=0;i<NUM;i++){
a1[i]=random.nextInt(NUM);
}int[]a2=Arrays.copyOf(a1, NUM);int[]a3=Arrays.copyOf(a1, NUM);int[]a4=Arrays.copyOf(a1, NUM);//排序算法比较，开始了... start=System.currentTimeMillis();
System.out.println("冒泡排序开始时间："+new Timestamp(start));
mpSort(a1);
end=System.currentTimeMillis();
System.out.println("冒泡排序结束时间："+new Timestamp(end));
System.out.println("长度为"+NUM+"的数组冒泡排序耗时"+(end-start)+"ms!");// for(int i=0;i<a1.length;i++){// System.out.print(a1[i]+",");// } System.out.print("\n"+"---------------"+"\n");

start=System.currentTimeMillis();
System.out.println("选择排序开始时间："+new Timestamp(start));
xzSort(a2);
end=System.currentTimeMillis();
System.out.println("选择排序结束时间："+new Timestamp(end));
System.out.println("长度为"+NUM+"的数组选择排序耗时"+(end-start)+"ms!");// for(int i=0;i<a2.length;i++){// System.out.print(a2[i]+",");// } System.out.print("\n"+"---------------"+"\n");

start=System.currentTimeMillis();
System.out.println("插入排序开始时间："+new Timestamp(start));
crSort(a3);
end=System.currentTimeMillis();
System.out.println("插入排序结束时间："+new Timestamp(end));
System.out.println("长度为"+NUM+"的数组插入排序耗时"+(end-start)+"ms!");// for(int i=0;i<a3.length;i++){// System.out.print(a3[i]+",");// } System.out.print("\n"+"---------------"+"\n");

start=System.currentTimeMillis();
System.out.println("快速排序开始时间："+new Timestamp(start));
quickSort(a4);
end=System.currentTimeMillis();
System.out.println("快速排序结束时间："+new Timestamp(end));
System.out.println("长度为"+NUM+"的数组快速排序耗时"+(end-start)+"ms!");// for(int i=0;i<a4.length;i++){// System.out.print(a4[i]+",");// }// System.out.print("\n\n"+"---------------"+"\n"); }//冒泡排序mpSort(int[])//比较:(n-1)+(n-2)+...+1次，最多交换(n-1)+(n-2)+...+1次//第1~n个,第1~n-1个,第1~n-2个...publicstaticvoid mpSort(int[] data) {for (int i=0; i<data.length-1; i++) {for(int j=0;j<data.length-1-i;j++){if(data[j]>data[j+1]){int temp= data[j];
data[j]= data[j+1];
data[j+1]= temp;
}
}
}
}//选择排序xzSort(int[])//比较(n-1)+(n-2)+...+1次，最多交换(n-1)次//第1~n个,第2~n个,第3~n个...publicstaticvoid xzSort(int[] data) {for (int i=0; i<data.length-1; i++) {int k=i;for(int j=i+1;j<data.length;j++){if(data[k]>data[j]){
k=j;
}
}int temp=data[i];
data[i]=data[k];
data[k]=temp;
}
}//插入排序//比较第i趟后，使得前i个有序publicstaticvoid crSort(int[] data) {for (int i=0; i<data.length; i++) {for (int j=0; j<i; j++) {if (data[i]<data[j]) {int temp= data[i];
data[i]= data[j];
data[j]= temp;
}
}
}
}//快速排序qsSort(int[])//采用2分算法publicstaticvoid quickSort(int[] array) {
quickSort(array,0, array.length-1);
}privatestaticvoid quickSort(int[] array,int low,int high) {if (low< high) {int p= partition(array, low, high);
quickSort(array, low, p-1);
quickSort(array, p+1, high);
}
}privatestaticint partition(int[] array,int low,int high) {int s= array[high];int i= low-1;for (int j= low; j< high; j++) {if (array[j]< s) {
i++;
swap(array, i, j);
}
}
swap(array,++i, high);return i;
}privatestaticvoid swap(int[] array,int i,int j) {int temp;
temp= array[i];
array[i]= array[j];
array[j]= temp;
}

}
10W测试结果：
冒泡排序耗时26313ms!
选择排序耗时11937ms!
插入排序耗时18985ms!
快速排序耗时15ms!

希望这个帖子能成为我的第一个“满意贴”
[/Quote]

[guaimutou]

学习

[timeriver_wang]

[Quote=引用 43 楼 haojia0716 的回复:]
引用 37 楼 wnjok 的回复:
引用 34 楼 zhangshan5588 的回复:
最简单是还是一楼的 lz理解就好了

一楼的不是冒泡排序，是插入排序，
这4中排序要比较才能区分开啊


Java codepublicstaticvoid sort(int[] data) {for (int i=0; i< data.length; i++) {
System.out.println(Arrays.toString(data));for (int j= i+1; j< data.length; j++) {if (data[i]> data[j]) {int temp= data[i];
data[i]= data[j];
data[j]= temp;
}
}
}
System.out.println(Arrays.toString(data));
}

那请问这是什么排序
[/Quote]

插入排序的变种啊
打印结果：
[9, 6, 8, 2, 3, 2, 2, 4, 8, 0]
[0, 9, 8, 6, 3, 2, 2, 4, 8, 2]
[0, 2, 9, 8, 6, 3, 2, 4, 8, 2]
[0, 2, 2, 9, 8, 6, 3, 4, 8, 2]
[0, 2, 2, 2, 9, 8, 6, 4, 8, 3]
[0, 2, 2, 2, 3, 9, 8, 6, 8, 4]
[0, 2, 2, 2, 3, 4, 9, 8, 8, 6]
[0, 2, 2, 2, 3, 4, 6, 9, 8, 8]
[0, 2, 2, 2, 3, 4, 6, 8, 9, 8]
[0, 2, 2, 2, 3, 4, 6, 8, 8, 9]
[0, 2, 2, 2, 3, 4, 6, 8, 8, 9]

结果显示：比较第i趟后，使得前i个有序

你这个
“for (int i = 0; i < data.length; i++) {
System.out.println(Arrays.toString(data));
”
很有创意啊

也可用eclipse在“外层for (int i = 0; i < data.length; i++) {”
设个断点能起到同样作用

[haojia0716]

呵呵 这看起来不是很像冒泡吗

管他什么冒泡插入 只是名字而已 而且我从来不用

说什么基本有序 倒序的情况 现实中也是很少遇到


还有内存极小情况的外部排序 现实中用到的情况也很少


一般都只用快速排序

[xuejelly]

33楼很强大

[hanger1212]

学习了

[lxxzhy]

我也来一个,嘿嘿

public static void sort(int[] src) {
		int len = src.length - 1;
		
		while(len > 0) {
			int lastChanged = 0;
			for(int i = 0; i < len; i++) {
				if(src[i] > src[i+1]) {
					src[i] = src[i] ^ src[i+1];
					src[i+1] = src[i] ^ src[i+1];
					src[i] = src[i] ^ src[i+1];
					lastChanged = i;
				}
			}
			len = lastChanged;
		}
	}

[SimpleM]

使用两个for作为冒泡排序的工具

public class PaiXu {
	public static void main(String[] args) {
		int[] score = new int[5];
                //给数组赋值1-50的随机数
		for (int i = 0; i < score.length; i++) {
			score[i] = (int) (Math.random() * 50) + 1;
		}
                //外循环控制比较次数
		for (int i = score.length; --i >= 0;) {
			// 内循环比较左右相邻的每个数字
			for (int j = 0; j < i; j++) {
                                //如果左边的数大于右边的数就换位置，把小的数冒泡
				if (score[j] > score[j + 1]) {
					// 将两个数字的位置进行对调
					int temp = score[j];
					score[j] = score[j + 1];
					score[j + 1] = temp;
				}
			}
		}
		// 循环整个数组输出结果
		for (int i = 0; i < score.length; i++) {
			System.out.print(score[i] + " ");// 每个数字后加一个空格
		}
		System.out.println();// 一行结束
	}

[timeriver_wang]

[Quote=引用 43 楼 haojia0716 的回复:]
引用 37 楼 wnjok 的回复:
引用 34 楼 zhangshan5588 的回复:
最简单是还是一楼的 lz理解就好了

一楼的不是冒泡排序，是插入排序，
这4中排序要比较才能区分开啊


Java codepublicstaticvoid sort(int[] data) {for (int i=0; i< data.length; i++) {
System.out.println(Arrays.toString(data));for (int j= i+1; j< data.length; j++) {if (data[i]> data[j]) {int temp= data[i];
data[i]= data[j];
data[j]= temp;
}
}
}
System.out.println(Arrays.toString(data));
}

那请问这是什么排序
[/Quote]

冒泡算法：
第一趟，第一个和第二个比较，把大的换到第二个；第二个和第三个比较，把大的换到第三个；
第三个和第四个比较，把大的换到第四个；。。。
以此类推，把大的沉到底部

插入算法：
第一趟，第一个和第二个比较，把小的换到第一个；第一个和第三个比较，把小的换到第一个；
第一个和第四个比较，把小的换到第一个；。。。
以此类推，把最小的放在第一个位置

你的这个“内层循环是":
for (int j= i+1; j< data.length; j++) {
if (data[i]> data[j])
...
}
i是不变的，所以是插入排序

如果是冒泡排序的话，应该是：if(data[j]>data[j+1]//即与i无关

[BearKin]

package sort;

/** 常用的数组排序方法 */
public class ArraySort {
public static void main(String[] args) {
   long[] i = { 5, 4, 8, 9, 1, 3, 2, 6, 7, 0 };

   // i = bubbleSort(i);
   // i = selectSort(i);
   // i = insertSort(i);
   // i = bubbleSortStrong(i);
   i = paritySort(i);
   for (int z = 0; z < i.length; z++) {
    System.out.print(i[z] + " ");
   }
}

/**
* 冒泡排序
* 
* @see 通过循环不断的把最大的值提到前面
*/
public static long[] bubbleSort(long[] i) {
   for (int out = 0; out < i.length; out++) {
    for (int in = out; in < i.length; in++) {
     if (i[in] > i[out]) {
      i = swap(i, out, in);
     }
    }
   }
   return i;
}

/**
* 另一种冒泡排序
* 
* @see 跟冒泡排序一样 不过是两头一起进行排序
* */
public static long[] bubbleSortStrong(long[] i) {

   for (int out = 0; out < i.length; out++) {
    for (int w = out; w < i.length; w++) {
     if (i[w] > i[out]) {
      i = swap(i, out, w);
     }
    }
    for (int e = (i.length - 1) - out; e > 0; e--) {
     if (i[e] < i[(i.length - 1) - out]) {
      i = swap(i, e, (i.length - 1) - out);
     }
    }
   }
   return i;
}

/**
* 选择排序
* 
* @see 冒泡排序的升级版 里循环的时候先提取出该数组中最大值的索引 然后外循环每循环一次交换一次值
* */
public static long[] selectSort(long[] i) {
   int out, in, min;
   for (out = 0; out < i.length - 1; out++) {
    min = out;
    for (in = out + 1; in < i.length; in++) {
     if (i[in] > i[min]) {
      min = in;
     }
    }
    i = swap(i, out, min);
   }
   return i;
}

/** 插入排序 
* 
* @see 。。。。我说不太明白 
* */
public static long[] insertSort(long[] i) {
   int in, out;
   for (out = 0; out < i.length; out++) {
    long temp = i[out];
    in = out;
    while (in > 0 && i[in - 1] < temp) {
     i[in] = i[in - 1];
     --in;
    }
    i[in] = temp;
   }
   return i;
}

/** 奇偶排序 */
public static long[] paritySort(long[] i) {
   boolean b = true;
   while (b) {
    b = false;
    for (int odd = 1; odd < i.length - 1; odd += 2) {
     if (i[odd] > i[odd + 1]) {
      swap(i, odd, odd + 1);
      b = true;
     }
    }
    for (int even = 0; even < i.length - 1; even += 2) {
     if (i[even] > i[even + 1]) {
      swap(i, even, even + 1);
      b = true;
     }
    }
   }
   return i;
}

/** 交换数组位置 */
public static long[] swap(long[] i, int x, int y) {
   long r;
   r = i[x];
   i[x] = i[y];
   i[y] = r;
   return i;
}
}

[liusong721]

48楼好全面啊!

[SimonYeung]

学习了 MARK 好贴

[qq619668777]

pubsic static void main(String[] args){
int [] a=new int []{3,5,-6,4,-1};
int b=a.length;
for(;--b>0;){
for(int index=0;index<b;index++){
if(a[index]>a[index+1]){
int temp=a[index];
a[index]=a[index+1];
a[index+1]=temp;
}
}
}
for(int index=0;index<a.length;index++){
System.out.println(a[index]);
}
}
大家看看我这个怎么样。简单不？