冒泡排序算法

冒泡排序
   
原理
      
 *      比较相邻的两个元素，如果第一个元素比第二个元素大，那就交换一下位置，
 *      每一对相邻的元素都要作比较，到最后最大的元素就到最后面了
 *      
 *      
 *      元素有n个，那比较的趟数就是n-1趟，
 *      每一趟都是相邻元素比较，一直到最后，最大的到最后一个，相邻比较的次数，没有都减一次

例如有一组数据{9,6,8,2,7}

规律  比较趟数=元素数减一
       第一趟比价次数等于元素个数减一每趟比较次数比上一次减一

 开始冒泡排序
 第一趟比较
 9,6,8,2,7
 9和6比较  9比6大  9和6交换位置  6,9,8,2,7
 然后9和8比较 9比8大 9和8 交换位置  6,8,9,2,7
 然后9和2比较 9比2大 9和2交换位置  6,8,2,9,7
 然后9和7比较 9比7大 9和7交换位置 6,8,2,7,9

 第一趟比较结束  比较了4次  一共五个元素参加


 第二趟比较
6,8,2,7,9
6和8比较 8比6大 不交换位置  6,8,2,7,9
然后8和2比较 8比2大 8和2交换位置  6,2,8,7,9
然后8和7比较 8比7大 8和7交换位置 6,2,7,8,9

第二趟比较  比较了3次   出来最大的9没有参加  其他4个都参加了

第三趟比较
6,2,7,8,9
6和2比较 6比2大 交换位置  2,6,7,8,9
然后6和7比较  6小于7  不交换位置 2,6,7,8,9

 第三趟比较  比较2次  出去最后的8 9 没参加  三个数参加

 第四趟比较
2,6,7,8,9
2和6比较  2小于6不交换位置  2,6,7,8,9

第四趟比较  比较一次

public class BubbleSorting {
    public static void main(String[] args){
        //首先定义一个数组
        int[] array={3,9,-1,10,20};

        int[] arr=new int[1];
        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++) {
                if (array[j] < array[j + 1]) {
                    arr[0] = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = arr[0];
                }
            }
                System.out.println("第"+(i+1)+"趟比较数组");
                System.out.println(Arrays.toString(array));

        }
        System.out.println("+++++++++++++++++++++");

        System.out.println(Arrays.toString(array));//输出结果是 [20, 10, 9, 3, -1]

        System.out.println("-------------------------------");

//调用冒泡排序方法

        bubble(array);
    }


//以下是封装了一个冒泡排序的方法

    //冒泡排序的方法（静态方法，直接调用）
    public static void bubble(int[] array){
        int[] arr=new int[1];
        for (int i=array.length-1;i>0;i--){//比较的趟数
            for (int j=0;j<i;j++){
                if (array[j]<array[j+1]){
                    arr[0]=array[j];
                    array[j]=array[j+1];
                    array[j+1]=arr[0];
                }
            }
            System.out.println("每趟比较后的数组");
            System.out.println(Arrays.toString(array));
            /*使用以上输出的数组长这样
第5趟比较后的数组
[9, 3, 10, 20, -1]
第4趟比较后的数组
[9, 10, 20, 3, -1]
第3趟比较后的数组
[10, 20, 9, 3, -1]
第2趟比较后的数组
[20, 10, 9, 3, -1]

             */
        }
        //for循环输出一维数组长这样    20 10 9 3 -1
       for (int i=0;i<array.length;i++){
           System.out.print(array[i]+" ");
       }
        System.out.println();
    }
}

为了提高冒泡排序的效率

进阶如下

public class BubbleSorting2 {
    public static void main(String[] args){
        int[] array={3,9,-1,10,20};
        int[] arr=new int[1];
        //优化
        boolean flay=false;//定义标志

        for (int i=0;i<array.length-1;i++){
            for (int j=0;j<array.length-1-i;j++){
                if (array[j]>array[j+1]){
                    flay=true;//将其值改为true，表示比较过
                    arr[0]=array[j];
                    array[j]=array[j+1];
                    array[j+1]=arr[0];
                }
            }
            if (flay==false){//如果这个标志flay的值是 false  表示没有进去比较，结束循for
                break;
            }else{
                flay=false;//表示进去比较过,需要重写赋值，为下一次准备
            }

            System.out.println("第"+(i+1)+"趟比较之后的数组");
            System.out.println(Arrays.toString(array));
            /*
            优化之后的结果，只比较两趟，不优化要比较四趟
第1趟比较之后的数组
[3, -1, 9, 10, 20]
第2趟比较之后的数组
[-1, 3, 9, 10, 20]
             */
        }
    }
}