冒泡排序

一、冒泡排序的介绍

• 冒泡排序(Bubble Sorting)的基本思想：通过对待排序序列从前向后（从下标较小的的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。
• 因为在排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序的过程中设置一个标志flag判断元素是否进行过交换。从而减少不必要的比较（这里说的是优化，可以在冒泡排序写好后，在进行）

二、代码实现

package sort.bubble.demo;
import java.util.Arrays;

public class BubbleSort {
public static void main(String[] args) {
    int arr[] = {3, 9, -1, 10, -2};
    //第一趟排序，就是将最大的数排在最后
    int temp = 0;//临时变量
    for (int j = 0; j < arr.length - 1; j++) {
        //如果前面的数比后面的大，则交换
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println("第一趟排序的结果："+ Arrays.toString(arr));

    //第二趟排序，将第二个最大的数排在倒数第二位
    for (int j = 0; j < arr.length - 1-1; j++) {
        //如果前面的数比后面的大，则交换
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println("第二趟排序的结果："+ Arrays.toString(arr));

    //第三趟排序
    for (int j = 0; j < arr.length - 1-1-1; j++) {
        //如果前面的数比后面的大，则交换
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println("第三趟排序的结果："+ Arrays.toString(arr));

    //第四趟排序
    for (int j = 0; j < arr.length - 4; j++) {
        //如果前面的数比后面的大，则交换
        if (arr[j] > arr[j + 1]) {
            temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
        }
    }
    System.out.println("第四趟排序的结果："+ Arrays.toString(arr));
}
}

第一趟排序的结果：[3, -1, 9, -2, 10]
第二趟排序的结果：[-1, 3, -2, 9, 10]
第三趟排序的结果：[-1, -2, 3, 9, 10]
第四趟排序的结果：[-2, -1, 3, 9, 10]

1.简化代码

package sort.bubble.demo;
import java.util.Arrays;

public class BubbleSort {
public static void main(String[] args) {
    int arr[] = {3, 9, -1, 10, -2};
    //第一趟排序，就是将最大的数排在最后
    int temp = 0;//临时变量
    for (int i = 0; i < arr.length - 1; i++) {

        for (int j = 0; j < arr.length - 1-i; j++) {
            //如果前面的数比后面的大，则交换
            if (arr[j] > arr[j + 1]) {
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第"+(i+1)+"趟排序的结果：" + Arrays.toString(arr));
    }
}
}

2.再次优化代码

package sort.bubble.demo;
import java.util.Arrays;

public class BubbleSort {
public static void main(String[] args) {
    int arr[] = {3, 9, -1, 10, -2};
    //第一趟排序，就是将最大的数排在最后
    int temp = 0;//临时变量
    boolean flag = false;//标识变量，表示是否进行过交换
    for (int i = 0; i < arr.length - 1; i++) {

        for (int j = 0; j < arr.length - 1 - i; j++) {
            //如果前面的数比后面的大，则交换
            if (arr[j] > arr[j + 1]) {
                flag = true;
                temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
        System.out.println("第" + (i + 1) + "趟排序的结果：" + Arrays.toString(arr));
        if (!flag) { //在一趟排序中，一次交换都没有发生
            break;
        } else {
            flag = false;  //重置flag，进行下次判断
        }
    }
}
}

将初始化的数组改变，测试，会有不同的循环次数。

三、冒泡排序的时间复杂度测试

package sort.bubble.demo;
import java.text.SimpleDateFormat;
import java.util.Date;

public class BubbleSort {
public static void main(String[] args) {
    //int arr[] = {3, 9, -1, 10, -2};
    //bubbleSort(arr);

    //测试冒泡排序的时间复杂度，花费的时间
    int[] arr = new int[80000];//定义数组长度
    for (int i = 0; i < 80000; i++) {
        //生成0～800000的随机整数
        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();
    String date2Str = simpleDateFormat.format(date2);
    System.out.println("排序前的时间是：" + date2Str);

}

public static void bubbleSort(int[] arr) {
   //冒泡排序的时间复杂度是O(n^2)
   int temp = 0;//临时变量
   boolean flag = false;//标识变量，表示是否进行过交换
   for (int i = 0; i < arr.length - 1; i++) {

       for (int j = 0; j < arr.length - 1 - i; j++) {
           //如果前面的数比后面的大，则交换
           if (arr[j] > arr[j + 1]) {
               flag = true;
               temp = arr[j];
               arr[j] = arr[j + 1];
               arr[j + 1] = temp;
           }
       }
       //System.out.println("第" + (i + 1) + "趟排序的结果：" + Arrays.toString(arr));
       if (!flag) { //在一趟排序中，一次交换都没有发生
           break;
       } else {
           flag = false;  //重置flag，进行下次判断
       }
   }
}
}