交换排序——冒泡排序（Bubble Sorting）

冒泡排序法

1. 基本介绍：如果想让待排序列从小到大排序，就对待排序列从前到后，依次比较相邻的元素的值，若发现逆序（前一个比后一个大）就交换，使值较大的元素逐渐从前向后移动，就像水底下的气泡一样逐渐上冒
2. 图解冒泡排序法的

• 

3. 总结：
   • 总共有n个元素，大排序排n - 1次，每一次大排序中的小排序次数依次递减
   • 优化，当某一次排序中未有任何元素的顺序改变，那就退出循环，不必排序
   • 每一次都确定最后一个元素

代码实现

我的代码：

package bubble;

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,9,-1,10,-2};
        //总共是五个元素，故而大排序是4次
        //大排序次数是数组长度-1次，
        int count = 0;
        //定义一个变量来计算排序次数
        for (int i = 0;i < arr.length - 1;i ++){
            //小排序随着大排序减少
            boolean isFlag = true;
            //每一次大排序之前isFlag都是真的，一旦经历了小排序那就是假的
            //每一次大排序完毕后都检测一下，有没有经历过小排序
            //如果没有那就直接退出，如果有那就再接着来
            for (int j = 0 ;j < arr.length - i - 1;j ++){
                //包含了一个零，所以这里请记住，特别容易错
                //逆序交换，有小到大排序，如果前一个比后一个大，那就交换排序顺序
                if(arr[j] > arr[j + 1]){
                    int temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    count ++;
                    isFlag = false;
                }
            }
            if (isFlag){
                break;
            }
        }
        for (int i = 0;i < arr.length;i ++){
            System.out.println(arr[i]);
        }
        System.out.println(count);
    }
}

教程代码：

package bubble;

public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {2,3,-1,9,10};
        //总共是五个元素，故而大排序是4次
        //大排序次数是数组长度-1次，

    }
    public static void bubbleSort(int[] arr){
        int temp = 0;
        //临时变量，用来交换值
        boolean isFlag  = true;
        //isFlag是参数标量，
        for (int i = 0;i < arr.length - 1;i ++){
            //小排序随着大排序减少
            //每一次大排序之前isFlag都是真的，一旦经历了小排序那就是假的
            //每一次大排序完毕后都检测一下，有没有经历过小排序
            //如果没有那就直接退出，如果有那就再接着来
            for (int j = 0 ;j < arr.length - i - 1;j ++){
                //包含了一个零，所以这里请记住，特别容易错
                //逆序交换，有小到大排序，如果前一个比后一个大，那就交换排序顺序
                if(arr[j] > arr[j + 1]){
                    temp = arr[j + 1];
                    arr[j + 1] = arr[j];
                    arr[j] = temp;
                    isFlag = false;
                }
            }

            if (isFlag){
                //如果再一次大排序中，一次小排序都没有发生过
                //isFlag就是真的不变
                break;
            }
            isFlag = true;
            //重置isFlag，进行下次判断，这是一定会执行的语句，没有必要加上else
          
        }
    }
}

总结与分析：

1. 冒泡排序大排序的次数，为数组长度减一——外层循环arr.length - 1次
2. 小排序的次数为数组长度减1减大排序——内层循环arr.length - 1 - i(i为外层的大排序）
   大总减一，小总减大减一
3. 优化算法的常用技巧：外层设置isFlag为true，如果进了内层就改为false，内层循环后添加if语句根据isFlag的值判定是否进过内层循环每一次判定完都要进行重置

没有必要像我写的那么分散！！

---

测试排序算法时间的代码

代码：

int[] arr = new int[80000];
        for(int i = 0;i < 80000;i ++){
            arr[i] = (int)(Math.random() * 8000000);
        }
        //随机产生八万个不同的数值的数组
        Date date1 = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
        String date1str = simpleDateFormat.format(date1);
        System.out.println("排序前的时间为" + date1str);
        bubbleSort(arr);
        Date date2 = new Date();
        SimpleDateFormat simpleDateFormat2 = new SimpleDateFormat("YYYY-MM-DD HH:mm:ss");
        String date2str = simpleDateFormat.format(date2);
        System.out.println("排序后的时间为" + date2str);

总结分析：忘得差不多了，关于常用类之中的时间类，回顾一下。
特定区间的随机数公式：RAND()*(B-A)+A，是否闭区间自己在加一