排序算法_冒泡排序

know what one is about2024-07-11 14:52

冒泡排序属于稳定排序算法

稳定排序指，按对象中不同字段进行多次排序，不会打乱同值元素的顺序；不稳定排序则反之。

例如：

java 复制代码

都是先按照花色排序（♠♥♣♦），再按照数字排序（AKQJ...）
不稳定排序算法按数字排序时，会打乱原本同值的花色顺序
[[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
[[♠7], [♠5], [♥5], [♠4], [♥2], [♠2]]
原来 ♠2 在前 ♥2 在后，按数字再排后，他俩的位置变了

稳定排序算法按数字排序时，会保留原本同值的花色顺序，如下所示 ♠2 与 ♥2 的相对位置不变
[[♠7], [♠2], [♠4], [♠5], [♥2], [♥5]]
[[♠7], [♠5], [♥5], [♠4], [♠2], [♥2]]

冒泡排序逻辑步骤：

依次比较数组中相邻两个元素大小，若 a $j$ > a $j+1$ ，则交换两个元素，两两都比较一遍称为一轮冒泡，结果是让最大的元素排至最后 2. 重复以上步骤，直到整个数组有序

java 复制代码

public static void bubbleV2(int[] a){
        int n = a.length -1;
        while (true){
            //每轮冒泡时，最后一次交换索引可以作为下一轮冒泡的比较次数，如果这个值为零，
            // 表示整个数组有序，直接退出外层循环即可
            int last = 0;//表示最后一次交换的位置
            for (int i = 0; i < n; i++) {
                System.out.println("比较次数" + i);
                if (a[i] > a[i+1]){
                    swap(a,i,i+1);
                    last = i;
                }
            }
            n = last;
            System.out.println("第"+ last +"轮冒泡"+Arrays.toString(a));
            if (n == 0){
                break;
            }
        }
    }
    public static void swap(int[] array,int i,int j){
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }

冒泡排序变种

需要保证奇数和奇数，偶数和偶数之间的相对位置不变，这和书本不太一样。例如对于 $1,2,3,4,5$ ，调整后得到 $1,3,5,2,4$ ，而不能是 {5,1,3,4,2} 这种相对位置改变的结果。

思路：

使用冒泡思想，每次都将当前偶数上浮到当前最右边。时间复杂度 O(N2)，空间复杂度 O(1)，时间换空间。

java 复制代码

public int[] bubbleV2(int[] nums){
        int N = nums.length;
        for (int i = N - 1; i > 0 ; i--) {
            for (int j = 0; j < i; j++) {
                if (isEven(nums[j]) && !isEven(nums[ j+ 1])){
                    swap(nums,j,j + 1);
                }

            }
        }
        return nums;
    }

    private boolean isEven(int x){
        return x % 2 == 0;
    }
    public void swap(int[] array,int i,int j){
        int t = array[i];
        array[i] = array[j];
        array[j] = t;
    }