算法——冒泡排序

• 【1】没有经过优化的冒泡排序：
• 【2】优化后的冒泡排序：
• 【3】测试结果：
• • 优化后：（30次）
  • 优化前：（45次）

//打印
    public static void prin(int[] arr){
        System.out.println("数组如下："+ Arrays.toString(arr));
    }

public static void baseSort(int[] arr){
        //两层循环嵌套
        //总共经历length-1次就能排序
        //临时变量
        int temp = 0;
        for (int i = 0; i < arr.length-1; i++) {
            //每一趟需要经过length-i-1次才能排序成功
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                System.out.println("经过第"+(++count)+"次排序");
            }
        }

    }

public static void optimizeBubble(int[] arr){
        //标识符 false表示没有交换过
        boolean flag = false;
        //两层循环嵌套
        //总共经历length-1次就能排序
        //临时变量
        int temp = 0;
        for (int i = 0; i < arr.length-1; i++) {
            //每一趟需要经过length-i-1次才能排序成功
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                System.out.println("经过第"+(++count)+"次排序");
            }
            if (!flag){
                //如果这一趟排序一次都没有交换过，后面的就不用排了
                break;
            }else {
                flag = false;
            }
        }

全部代码：

package algorithm.sort.bubbleSort;

import java.util.Arrays;

public class baseBubbleSort {
    private static  int count =0 ;
    public static void main(String[] args) {
        int[] arr = {-2,-1,-4,6,4,7,0,13,15,17};
//        baseSort(arr);
        optimizeBubble(arr);
        prin(arr);

    }
    //基本排序不经过优化
    public static void baseSort(int[] arr){
        //两层循环嵌套
        //总共经历length-1次就能排序
        //临时变量
        int temp = 0;
        for (int i = 0; i < arr.length-1; i++) {
            //每一趟需要经过length-i-1次才能排序成功
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                System.out.println("经过第"+(++count)+"次排序");
            }
        }

    }
    //经过优化的冒泡排序
    public static void optimizeBubble(int[] arr){
        //标识符 false表示没有交换过
        boolean flag = false;
        //两层循环嵌套
        //总共经历length-1次就能排序
        //临时变量
        int temp = 0;
        for (int i = 0; i < arr.length-1; i++) {
            //每一趟需要经过length-i-1次才能排序成功
            for (int j = 0; j < arr.length-i-1; j++) {
                if(arr[j]>arr[j+1]){
                    flag = true;
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
                System.out.println("经过第"+(++count)+"次排序");
            }
            if (!flag){
                //如果这一趟排序一次都没有交换过，后面的就不用排了
                break;
            }else {
                flag = false;
            }
        }


    }
    //打印
    public static void prin(int[] arr){
        System.out.println("数组如下："+ Arrays.toString(arr));
    }
}