排序算法---冒泡排序

基于交换的排序、稳定的排序

第一趟：对所有n个元素，从第一个元素开始，比较相邻的两个元素，如果逆序，调换；在第一轮比较完之后，最大（小）的元素就会在最后一个位置

第二趟：对前n-1个元素，从第一个元素开始，比较相邻的两个元素，如果逆序，调换，在第二轮比较完之后，第二大（小）的元素就会在倒数第二位置

……

一共比较n-1趟

    //冒泡排序，从小到大
    public static void bubbleSort(int[] array){
        int length = array.length;
        int temp= 0;
        for(int i=0;i<length-1;i++){//第几趟，一共n-1趟
            for(int j=0;j<length-1-i;j++){//每一趟对前n-i个数进行两两比较
                if(array[j] > array[j+1]){//如果逆序，交换；否则，什么也不做
                    /*temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;*/
                    array[j] = array[j]^array[j+1];
                    array[j+1] = array[j]^array[j+1];
                    array[j] = array[j]^array[j+1];
                }
            }
            System.out.print("第"+i+"趟:");
            listArray(array);
        }
    }

原始数据：49 38 65 97 76 13 27 49
第1趟:38 49 65 76 13 27 49 97
第2趟:38 49 65 13 27 49 76 97
第3趟:38 49 13 27 49 65 76 97
第4趟:38 13 27 49 49 65 76 97
第5趟:13 27 38 49 49 65 76 97
第6趟:13 27 38 49 49 65 76 97
第7趟:13 27 38 49 49 65 76 97

改进：

如果某一趟没有交换操作，证明该趟数据已经从小到大排好序了，不用再进行之后的操作

    //冒泡排序，从小到大
    public static void bubbleSort(int[] array){
        int length = array.length;
        int temp= 0;
        
        for(int i=0;i<length-1;i++){//第几趟，一共n-1趟
            boolean flag = false;
            for(int j=0;j<length-1-i;j++){//每一趟对前n-i个数进行两两比较
                if(array[j] > array[j+1]){//如果逆序，交换；否则，什么也不做
                    /*temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;*/
                    array[j] = array[j]^array[j+1];
                    array[j+1] = array[j]^array[j+1];
                    array[j] = array[j]^array[j+1];
                    flag = true;
                }
            }
            System.out.print("第"+(i+1)+"趟:");
            listArray(array);
            //每趟排序完之后，都看看该趟是否有交换操作，如果没有交换操作，证明该趟排序完之后，已经排好序了
            if(flag == false){
                break;
            }
            
        }
    }

原始数据：49 38 65 97 76 13 27 49
第1趟:38 49 65 76 13 27 49 97
第2趟:38 49 65 13 27 49 76 97
第3趟:38 49 13 27 49 65 76 97
第4趟:38 13 27 49 49 65 76 97
第5趟:13 27 38 49 49 65 76 97
第6趟:13 27 38 49 49 65 76 97

改进前

平均、最好、最差时间复杂度都是 O(n^2)

改进后

平均、最差O(n^2)   最好O(n)（本来就有序的情况下）