冒泡排序的几种形式

[eimhee]

解释一下原因, 为什么有下面两种形式,越详细越好
还有没有其它形式的变形呢?

1. /**
2. * 冒泡排序算法
3. */
4. public class BubbleSort {
5. public static void sort(int[] values) {
6. int temp;
7. for (int i = 0; i < values.length; ++i) {
8. for (int j = 0; j < values.length - i - 1; ++j) {
9. if (values[j] > values[j + 1]) {
10. temp = values[j];
11. values[j] = values[j + 1];
12. values[j + 1] = temp;
13. }
14. }
15. }
16. }
17. }




---------------------------------------------------------
int[] bubble(int a[]){ //函数
int temp;
int size = a.length;
for(int i = size - 1;i>=1;i--){
for(int j = 0;j<i;j++){
if (a[j]>a[j+1]){ 此处可以调整升序与降序
temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}

[goodmrning]

1.  /**  
   2.  * 冒泡排序算法  
   3.  */   
   4. public class BubbleSort {   
   5.     public static void sort(int[] values) {   
   6.         int temp;   
   7.         for (int i = 0; i   < values.length; ++i) {   //从数组中的第一个元素开始,遍历整个数组
   8.             for (int j = 0; j   < values.length - i - 1; ++j) {  //进行一轮比较,共需次 
   9.                 if (values[j] > values[j + 1]) {  //交换 
  10.                     temp = values[j];   
  11.                     values[j] = values[j + 1];   
  12.                     values[j + 1] = temp;   
  13.                 }   
  14.             }   
  15.         }   
  16.     }   
  17. }  
  

这个算法还好理解吧

[goodmrning]

1.  /**  
   2.  * 冒泡排序算法  
   3.  */   
   4. public class BubbleSort {   
   5.     public static void sort(int[] values) {   
   6.         int temp;   
   7.         for (int i = 0; i   < values.length; ++i) {   //从数组中的第一个元素开始,遍历整个数组
   8.             for (int j = 0; j   < values.length - i - 1; ++j) {  //进行一轮比较,共需values.length-i次 
   9.                 if (values[j] > values[j + 1]) {  //交换 
  10.                     temp = values[j];   
  11.                     values[j] = values[j + 1];   
  12.                     values[j + 1] = temp;   
  13.                 }   
  14.             }   
  15.         }   
  16.     }   
  17. }  

漏了

[goodmrning]

还可以这样写:

int[] bubble(int a[]){ //函数 
      int temp; 
      int size = a.length; 
      for(int i = size - 1;i>=1;i--){ 
        for(int j = 0;j <i;j++){ 
          if (a[j]>a[j+1]){ 此处可以调整升序与降序 
            a[j]=a[j]^a[j+1];
           a[j+1]=a[j+1]^a[j];
           a[j]=a[j]^a[j+1]; 
        } 
} 

[eimhee]

yangliyun2008写错了, 少比较了一次

[roc230]

public BubbleSort class  
{
	public void bubbleSort(int[]array){
		for(int i = 1; i < array.length; i++){
			for(int j = array.length-1; j > i; j--){
				if(array[j] < array[j-1]){
					swap(array, j, j-1);
				}
			}
		}
	}
         //交换arary[i]和array[j]独立出来,对于初学者也许会增加程序可读性
	private void swap(int[]array, int i, int j){
		int temp = array[i];
		array[i] = array[j];
		array[j] = temp;
	}

}
}

[eimhee]

我是想让你们帮我从原理上解释一下, 为什么有两种形式的写法?

[yangliyun2008]

我觉得没错.

[abner_me]

一个是从上往下遍历数组，一个至尾向前遍历数组。
理论方法都是一样的。俩循环：
1：比较n个数需要比较n-1趟
2：第J趟需要比较n-j次

[zero1111]

为什么冒泡排序比较时,不用数组保存他的指针呢？
而是换值呢？ 建议用指针吧.

[yangliyun2008]

1. /**
2. * 冒泡排序算法
3. */
4. public class BubbleSort {
5. public static void sort(int[] values) {
6. int temp;
7. for (int i = 0; i < values.length-1; ++i) { //执行n-1次就足够了吧
8. for (int j = (values.length-2); j>=i; j--) {
9. if (values[j] > values[j + 1]) {
10. temp = values[j];
11. values[j] = values[j + 1];
12. values[j + 1] = temp;
13. }
14. }
15. }
16. }
17. }

[yangliyun2008]

1. /**
2. * 冒泡排序算法
3. */
4. public class BubbleSort {
5. public static void sort(int[] values) {
6. int temp;
7. for (int i = 0; i < values.length-1; ++i) { //执行n-1次就足够了吧
8. for (int j = (values.length-2); j>=i; j--) {
9. if (values[j] > values[j + 1]) {
10. temp = values[j];
11. values[j] = values[j + 1];
12. values[j + 1] = temp;
13. }
14. }
15. }
16. }
17. }