2021-10-10

冒泡排序

1、什么是冒泡排序：

冒泡排序（Bubble Sort），它重复地走访过要排序的元素列，依次比较两个相邻的元素，如果顺序（如从大到小）错误就把他们交换过来。重复地进行循环，直到没有相邻元素需要交换，也就是说该元素列已经排序完成。

2、冒泡排序的代码示例

//冒泡排序
    static void bubbleSort(int[] arr){
        for(int i = 0;i<arr.length-1;i++){
            for(int j = 0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }

3、时间复杂度分析及稳定性

时间复杂度 ：O（n^2）
最好情况下：O（n）（改进后的冒泡）
最坏情况下：O（n^2）
空间复杂度：O（1）

稳定性：稳定

4、改进后的冒泡排序

原理：若本身已是升序排列，则停止循环

    //冒泡排序
    static void bubbleSort(int[] arr){
        for(int i = 0;i<arr.length-1;i++){
            //设置一个标志：若本身就为升序排列，则停止循环
            boolean flag = false;
            for(int j = 0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
            if(flag = true)
                break;
        }
    }   

5、验证

因为排序次数少或者原始数据较少可能会产生偶然性，应该编写程序验证选择排序算法的正确性。

package Sort;

import java.util.Arrays;
import java.util.Random;

public class Bubble {
    public static void main(String[] args) {
        check();
    }

    //验证排序算法的正确性
    static void check(){
        int[] arr = generateRandomArray();
        //复制一个数组，一个用Java自带的Array.sort()方法，另外一个用自己写的选择排序
        int[] arr2 = new int[arr.length];
        //系统自带的拷贝算法
        System.arraycopy(arr,0,arr2,0,arr.length);
        //第一个用系统的Arrays.sort()方法进行排序
        Arrays.sort(arr);
        //第二个用自己写的排序算法
        bubbleSort(arr2);
        boolean same = true;
        for(int i = 0;i<arr2.length;i++){
            if(arr[i]!=arr2[i])
                same=false;
        }
        System.out.println( same == true ? "right":"wrong");
    }

    //产生一个随机数组
    static int[] generateRandomArray(){

        int[] array = new int[10000];
        Random r = new Random();
        for(int i=0;i<array.length;i++)
        {
            array[i]=r.nextInt(10000);
        }
        return array;

    }

    //冒泡排序
    static void bubbleSort(int[] arr){
        for(int i = 0;i<arr.length-1;i++){
            //设置一个标志：若本身就为升序排列，则停止循环
            boolean flag = false;
            for(int j = 0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    int temp=arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = true;
                }
            }
            if(flag = true)
                break;
        }
    }

    //打印数组
    static void printArr(int[] array){
        for(int i:array)
        {
            System.out.print(" "+i);
        }
    }

    //交换数组的两个元素的值
    static void swap(int[] arr ,int i,int j){
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

}