怎样使用冒泡排序，它的代码怎样写

1. class BubbleSort
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 System.out.println("********冒泡排序！********");
   
6. 
   
7.                 //定义一个整数类型的数组，长度为10
   
8.                 int arr[] = {12,3,45,23,56,7,56,11,20,30};
   
9.                
   
10.                 //排序之前的数组
    
11.                 System.out.println("数组排序之前：");
    
12.                 printArray(arr);
    
13.                
    
14.                 //调用排序的方法对数组进行排序
    
15.                 bubbleSort(arr);
    
16. 
    
17.                 //打印输出数组中的整数
    
18.                 System.out.println("数组排序之后：");
    
19.                 printArray(arr);
    
20.         }
    
21. 
    
22.         public static void bubbleSort(int arr[]){
    
23. 
    
24.                 /*冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。
    
25.                 * 即首先比较第1个和第2个数，将小数放前，大数放后。
    
26.                 * 然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。
    
27.                 * 重复以上过程，仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再大于第2个数），
    
28.                 * 将小数放前，大数放后，一直比较到最小数前的一对相邻数，将小数放前，大数放后，第二趟结束，
    
29.                 * 在倒数第二个数中得到一个新的最小数。如此下去，直至最终完成排序。
    
30.                 */
    
31.                 for(int i=0; i<arr.length; i++){
    
32.                         for(int j=0; j<arr.length-i-1; j++){
    
33.                                 if(arr[j]>arr[j+1]){
    
34.                                         swap(arr, j, j+1);
    
35.                                 }
    
36.                         }
    
37.                 }
    
38.         }
    
39. 
    
40.         /*此方法用于相互交换数组中的两个数
    
41.         * 定义一个临时变量temp用于存储其中一个数
    
42.         */
    
43.         public static void swap(int arr[], int a, int b){
    
44.                 int temp = arr[a];
    
45.                 arr[a] = arr[b];
    
46.                 arr[b] = temp;
    
47.         }
    
48. 
    
49.         //循环出数组中的每一个元素
    
50.         public static void printArray(int arr[]){
    
51.                 for(int i=0; i<arr.length; i++){
    
52.                         System.out.print(arr[i] + "\t");
    
53.                 }
    
54.         }
    
55. 
    
56. }

复制代码

将楼上的那位哥们代码，换个写法

1. 
   
2. /**
   
3. * 冒泡排序
   
4. *
   
5. * @author Administrator
   
6. *
   
7. */
   
8. public class BubbleSort {
   
9. 
   
10.         public static void main(String[] args) {
    
11.                 int[] intArray = { 45, 36, 55, 77, 66, 12, 26 };
    
12. 
    
13.                 System.out.println("排序前的数组元素：");
    
14.                 printArray(intArray);
    
15. 
    
16.                 // 对数组进行冒泡排序
    
17.                 bubbleSort(intArray);
    
18. 
    
19.                 System.out.println("\n排序后的数组元素：");
    
20.                 printArray(intArray);
    
21.         }
    
22. 
    
23.         /*
    
24.          * 冒泡排序
    
25.          */
    
26.         public static void bubbleSort(int[] intArray) {
    
27.                 for (int i = 0; i < intArray.length; i++) {
    
28.                         for (int j = 0; j < intArray.length - i - 1; j++) {
    
29.                                 if (intArray[j] > intArray[j + 1]) {
    
30.                                         swap(intArray, j, j + 1);
    
31.                                 }
    
32.                         }
    
33.                 }
    
34.         }
    
35. 
    
36.         /*
    
37.          * 交换元素
    
38.          */
    
39.         public static void swap(int[] intArray, int i, int j) {
    
40.                 intArray[i] = intArray[i] ^ intArray[j];
    
41.                 intArray[j] = intArray[j] ^ intArray[i];
    
42.                 intArray[i] = intArray[i] ^ intArray[j];
    
43.         }
    
44. 
    
45.         /*
    
46.          * 遍历数组元素
    
47.          */
    
48.         public static void printArray(int[] intArray) {
    
49.                 for (int a : intArray) {
    
50.                         System.out.print(a + "\t");
    
51.                 }
    
52.         }
    
53. 
    
54. }
    

复制代码

楼上正解

看起来好复杂啊!

善用搜索,这个问题都回复好几遍了

顶贴是一种美德

看一看。。。。。。。。。。。

TCK8888 发表于 2016-5-19 20:27
将楼上的那位哥们代码，换个写法

使用位运算进行元素交换

学习了，受教

学习了，受教

一楼正解.........