冒泡排序的几种形式

Question

  解释一下原因, 为什么有下面两种形式,越详细越好
还有没有其它形式的变形呢? 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;
        }
} 

Answer 1

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. }  
  
这个算法还好理解吧

Answer 2

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. }  
漏了

Answer 3

还可以这样写:
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]; 
        } 
} 

Answer 4

 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. }    

Answer 5

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. }     

Answer 6

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;
}}
}

Answer 7

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

Answer 8

yangliyun2008写错了, 少比较了一次