排序算法总结之冒泡排序

经典的冒泡排序：

import java.util.Arrays;

public class BubbleMain {
    public static void main(String[] args) {
        int[] arr = new int[]{1,-2,3,10,-4,7,2,-5};
        BubbleSort(arr);
//        for(int i : arr){
//            System.out.print(i+" ");
//        }
        System.out.println(Arrays.toString(arr));
    }
    //从小到大  冒泡排序
    public static  void BubbleSort(int[] arr){
        int temp = arr[0];
        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]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
    }
}

改进一

放置一个标志位，当数组中没有元素交换的时候，即已经有序了。此时，就不用再继续扫描排序了，可以直接break出来。

import java.util.Arrays;

public class BubbleMain {
    public static void main(String[] args) {
        int[] arr = new int[]{1,-2,3,10,-4,7,2,-5};
        BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    //从小到大  冒泡排序
    public static  void BubbleSort(int[] arr){
        int temp = arr[0];
        for(int i= 0 ;i< arr.length-1;i++){
            boolean flag = true;//表示没有需要交换的数据
            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;
                    flag = false; //表示有交换
                }
            }
            if(flag) {//表示这一趟下来 没有需要交换的数据，说明数据此时已经全部有序，可以退出了
                break;
            }
        }
    }
}

改进二

设置无序数组的一个边界，这样只用扫描无序的数组，有序的部分可以无需扫描。

public class BubbleMain {
    public static void main(String[] args) {
        int[] arr = new int[]{1,-2,3,10,-4,7,2,-5};
        BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    
    //从小到大  冒泡排序
    public static  void BubbleSort(int[] arr){
        int temp = arr[0];
        int lastSwapIndex = 0;//表示最后进行交换的地方
        int bounder = arr.length-1;//无序数组的边界,每次比较到这里为止
        for(int i= 0 ;i< arr.length-1;i++){
            boolean flag = true;//表示没有需要交换的数据
            for(int j = 0;j< bounder;j++){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                    flag = false; //表示有交换
                    lastSwapIndex = j;//记录下最后一次交换的位置
                }
            }
            
            bounder = lastSwapIndex;//把最后一次交换元素的位置赋值给无序数组的边界
            if(flag) {//表示这一趟下来 没有需要交换的数据，说明数据此时已经全部有序，可以退出了
                break;
            }
        }
    }
}

补充一

冒泡排序里面需要交换两个元素的位置，交换两个元素可以用异或的操作，这样不需要创建第三个变量，减少内存开销。

可以对排序过程中交换两个元素的方法修改如下：

if (array[j] > array[j + 1]) {
    array[j + 1] ^= array[j];
    array[j] ^= array[j + 1];
    array[j + 1] ^= array[j];
}

补充二

如果数组不是给定的，是以“ , ”分隔输入的字符，则需要对数组进行处理转化一下：

import java.util.Arrays;
import java.util.Scanner;

public class BubbleMain {
    public static void main(String[] args) {
        //int[] arr = new int[]{1,-2,3,10,-4,7,2,-5};
        Scanner in = new Scanner(System.in);
        String str = in.nextLine();
        String[] arry_str = str.split(",");//将字符以,分隔
        int[] arr = new int[arry_str.length];
        for(int i =0; i<arr.length;i++){
            arr[i] = Integer.parseInt(arry_str[i]);//将字符转化成int类型
        }
        BubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }

以上所有代码运行，排序后均输出：

[-5, -4, -2, 1, 2, 3, 7, 10]

参考链接：https://blog.csdn.net/weixin_43570367/article/details/102763690