package com.heima.debug;

public class BubbleSort {

       
        public static void main(String[] args) {
                int[] arr = {24, -69, 80, 57, -13};
                int index=0;                                                                        //索引，记录较小值（较大）
                int temp;                                                                                //中间变量
                for (int i = 0; i < arr.length-1; i++) {                //比较次数为arr.length-1
                        temp = arr[i];                                                               
                        for (int j = i+1; j < arr.length; j++) {        //相邻两数比较
                                if (temp>arr[j]) {                                               
                                        temp=arr[j];                                                //如果temp>arr[j]，记录小的arr[j]                       
                                        index=j;                                                        //记录更小的索引
                                }
                        }
                        swap(arr,index,i);                                                        //外循环结束一次，就把最小的temp跟arr[i]交换
                }
                print(arr);
        }
        public static void swap(int[]arr,int a,int b){                //交换
                int temp=arr[b];
                        arr[b]=arr[a];
                        arr[a]=temp;
        }
        public static void print(int[]arr){                                        //输出新的数组
                for (int i = 0; i < arr.length; i++) {
                        System.out.print(arr[i]+"        ");
                }
        }

}

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

复制代码