求教冒泡排序

qiongfengcai 2009-09-10 11:09:34
为什么我每次见到的冒泡排序都是不一样的呢？？？
　
并且我在看冒泡的时候老是看得乱乱的。。

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

谢谢。。。。
...全文
904 56 打赏 收藏 举报
写回复
用AI写文章
56 条回复
切换为时间正序
请发表友善的回复…
发表回复
qq619668777 2011-07-03
  • 打赏
  • 举报
 回复
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]);
}
}
大家看看我这个怎么样。简单不？
SimonYeung 2009-09-17
  • 打赏
  • 举报
 回复
学习了 MARK 好贴
liusong721 2009-09-16
  • 打赏
  • 举报
 回复
48楼好全面啊!
BearKin 2009-09-16
  • 打赏
  • 举报
 回复 


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;

}

}
timeriver_wang 2009-09-16
  • 打赏
  • 举报
 回复
[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无关
SimpleM 2009-09-16
  • 打赏
  • 举报
 回复
使用两个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();// 一行结束

	}
lxxzhy 2009-09-16
  • 打赏
  • 举报
 回复
我也来一个,嘿嘿



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;

		}

	}
hanger1212 2009-09-15
  • 打赏
  • 举报
 回复
学习了
xuejelly 2009-09-15
  • 打赏
  • 举报
 回复
33楼很强大
haojia0716 2009-09-15
  • 打赏
  • 举报
 回复
呵呵 这看起来不是很像冒泡吗

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

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


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


一般都只用快速排序
timeriver_wang 2009-09-15
  • 打赏
  • 举报
 回复
[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++) {”
设个断点能起到同样作用
guaimutou 2009-09-15
  • 打赏
  • 举报
 回复
学习
cs0301lm 2009-09-15
  • 打赏
  • 举报
 回复
我的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]
haojia0716 2009-09-14
  • 打赏
  • 举报
 回复
[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));

    }


那请问这是什么排序
jacksonlai 2009-09-14
  • 打赏
  • 举报
 回复
回答得相当踊跃啊！！
Allsochen 2009-09-14
  • 打赏
  • 举报
 回复
本人建议用Eclipse中的DEBUG来看整个数组的变化过程，这样对你理解冒泡排序很有帮助。
itolddd9720 2009-09-14
  • 打赏
  • 举报
 回复
支持楼上的，要懂得原理，问题就简单了。
pywepe 2009-09-14
  • 打赏
  • 举报
 回复

lz切记呀 要懂原理

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

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

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

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

...

以些类推

这样就是10个数
外层循环10次
内层循环从10-1次开始递减
WuBill 2009-09-14
  • 打赏
  • 举报
 回复
外层从后往前
里层从前往后
[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;
}
}
}
}
timeriver_wang 2009-09-14
  • 打赏
  • 举报
 回复
[Quote=引用 34 楼 zhangshan5588 的回复:]
最简单是还是一楼的 lz理解就好了
[/Quote]
一楼的不是冒泡排序，是插入排序，
这4中排序要比较才能区分开啊
加载更多回复（36）
c语言结构体冒泡排序,c语言结构体冒泡排序求教
c语言结构体冒泡排序求教0姜默默2点02017.05.20浏览53次分享举报用冒泡排序输出每个学生的信息，新人求大神教学这个程序哪错了还有麻烦亲把修改过的发上来吧谢谢了for(j=0;jstu[i+1].pi... 用冒泡排序输出每个学生的信息，新人求大神教学 这个程序哪错了还有麻烦亲把修改过的发上来吧 谢谢了for(j=0;jstu[i+1].pingjun){temp.name=stu[i]...
C语言冒泡排序
冒泡排序？不难，这篇就够了！ for(int i=0;i
双向冒泡排序 冒泡排序 性能对比
双向冒泡排序 冒泡排序 性能对比 数据结构与算法与语言无关，此篇博文用的描述语言是go 冒泡排序 冒泡排序的时间复杂度是O(n2) 先看一个简单的冒泡排序 //普通冒泡排序 func normalBubbleSort(sequence []int){ for i := 0;i &lt; len(sequence) - 1;i++ { for j := 0;...
冒泡排序与链表的冒泡排序
首先看一看简单的冒泡排序是如何实现的： #include <stdio.h> int main() { int a[100],n; printf("请输入数组元素个数：\n"); scanf("%d",&n); printf("请输入数组元素：\n"); for(int k=0;k<n;k++) scanf("%d",&a[k]); /*冒泡排序*/ for(int i=0;i<(n-1);i++) //对于n个数，只需进行n-1次循环排序 f
冒泡排序和双向冒泡排序算法
冒泡排序算法应该算是每个开发者入门必学的基础算法，它逻辑清晰简单，代码实现也并不复杂，这里用自己的话语来总结一下。 （这些为了方便随便打开了一个node项目写的，其他Java ，PHP，C等也是一样的道理，算法讲究的只是一个思维模式，知道怎么去实现就行，不要死抠语言） 先说简单的普通冒泡排序： 冒泡排序既然是一个排序算法，那么它就一定是有一个循环排序的过程，其实它的原理很简单，就是两层for循环嵌...
Java SE

62,620

社区成员

307,251

社区内容

发帖
与我相关
我的任务
社区描述
Java 2 Standard Edition
社区管理员
  • Java SE
加入社区
  • 近7日
  • 近30日
  • 至今

加载中

查看更多榜单
社区公告
暂无公告

试试用AI创作助手写篇文章吧

+ 用AI写文章