java实现冒泡排序

Posted 2021-08-01 HardyDragon_CC

java实现冒泡排序

• 前言
• BubbleSort 冒泡排序
• • 调试
• 使用交换 flag 优化
• • 调试
• 总结

前言

C语言实现冒泡排序 在主函数调用

之前使用C实现过冒泡，但是不够精炼，描述不够简洁，便使用java来重新输出一下。

BubbleSort 冒泡排序

排序动画演示网站（建议收藏）

冒泡排序是将一个无序的序列（例如数组），从头开始两两比较交换直到有序的过程，每轮两两交换可以让后面部分元素有序。

例如，{3,9,6} 当交换比较到 {3,6,9} 后两个元素（数组大小 3 - 1 = 2 ）有序时，整体有序。

下面的 demo 是进行升序（小到大）排序的，实现降序只需要改变交换的条件即可。

package sort;

/**
 * @Description: Bubblesort
 * @author: HardyDragon
 * @date: 2021年07月06日 9:49
 */
public class Bubblesort {
    /***
     * @Description: Bubblesort
     * @author: HardyDragon
     * @date: 2021/7/6 9:49
     * @param nums: 无序数组
     * @Return: void
     */
    public void bubblesort(int[] nums) {
        if (nums.length < 2) {
            System.out.println("数组长度小于2的不用排序");
            return;
        }
        int size, temp;
        size = nums.length;

        // 外循环 size - 1次，两两交换轮数，i 表示倒数i个元素已经有序
        for (int i = 0; i < size - 1; i++) {
            // 内循环 size - 1 - i,防止 j+1 越界
            for (int j = 0; j < size - 1 - i; j++) {
                // 内循环前项j 比 后项j+1 ,小的放后边。
                if (nums[j] > nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }
    }
}

调试

package sort;

/**
 * @Description: TODO
 * @author: HardyDragon
 * @date: 2021年07月06日 9:57
 */
public class Main {
    public static void main(String[] args) {
        int[] nums = {45, 29, 40, 25, 98, 77, 46, 20, 21, 97};
        Bubblesort bubblesort = new Bubblesort();
        bubblesort.bubblesort(nums);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
}

20 21 25 29 40 45 46 77 97 98 

使用交换 flag 优化

当两两交换遇到下面情况，可以不用继续比较了，因为在这趟扫描过程中没有任何交换发生，我们现在可以终止冒泡排序。

public void BubbleSortFlag(int[] nums) {
    if (nums.length < 2) {
        System.out.println("数组长度小于2的不用排序");
        return;
    }
    int size, temp, flag;
    size = nums.length;

    // 外循环 size - 1次，两两交换轮数，i 表示倒数i个元素已经有序
    for (int i = 0; i < size - 1; i++) {
        // 每次循环前将flag置0，表示没有发生交换
        flag = 0;
        // 内循环 size - 1 - i,防止 j+1 越界
        for (int j = 0; j < size - 1 - i; j++) {
            // 内循环前项j 比 后项j+1 ,小的放后边。
            if (nums[j] > nums[j + 1]) {
                // 交换flag置1，说明发生了交换，前面元素无序
                flag = 1;
                temp = nums[j];
                nums[j] = nums[j + 1];
                nums[j + 1] = temp;
            }
        }
        // 这趟扫描没有发生交换，说明前面元素有序，可以终止排序
        if (flag == 0) {
            break;
        }
    }
}

调试

Debug 时，程序会在以下情况直接终止。

public class Main {
    public static void main(String[] args) {
        int[] nums = {29,10,14,37,14};
        Bubblesort bubblesort = new Bubblesort();
        bubblesort.BubbleSortFlag(nums);
        for (int num : nums) {
            System.out.print(num + " ");
        }
    }
}

10 14 14 29 37 

总结

冒牌排序关键在于两两交换，可以使用 flag 标示当前扫描是否发生交换来判断前面元素是否有序，进而提前结束程序。

• 外循环 size -1 次
• 内循环 防止 j + 1 越界，若以0初始化 j ,循环 size - 1 - i 次。可以不以0开始，但是要注意越界。
• 内循环前项比较后项 确定是否交换，实现升序/降序。