冒泡排序【20230130】

原理

1. 将相邻的两个元素进行比较
2. 符合要求元素位置不做变动
3. 不符合要求元素交换位置

比较的规律：
第1个与第2个进行比较
第2个与第3个进行比较
第3个与第4个进行比较
… …
第nums.length-2个与第nums.length-1个进行比较
使用双重for循环，终止条件是i < nums.length-1

    /**
     * 冒泡排序
     * 相邻的两个元素进行比较，如果符合要求，可以不动，不符合要求两者就交换位置
     * @param nums 给出的无序数组
     * @return 返回排好序的有序数组
     */
    public int[] bubbleSort(int[] nums){
        for (int i = 0; i < nums.length-1; i++) {

            boolean signOrdered = true;

           
            for (int j = 0; j < nums.length - 1; j++) {

                // 拿第一个与第二个比较，第二个与第三个比较以此类推
                if (isAsc && nums[j] > nums[j+1]){
                    // 不符合排序要求就交换位置
                    swap(nums,j,j+1);
                }
            }
            System.out.println("第" + (i+1) + "轮冒泡" + Arrays.toString(nums));
        }
        return nums;
    }

    /**
     * 交换数组元素
     * @param ints 数组
     * @param i 数组下标
     * @param j 数组下标
     */
    public void swap(int[] ints, int i,int j){
        int temp =  ints[i];
        ints[i] = ints[j];
        ints[j] =temp;
    }


    @Test
    public void bubbleSortTest(){
        int[] nums = {1,56,3,85,12,34,97,2,-89,4,33,77,66,22,11,0};
        int[] ints = bubbleSort(nums);
        for (int anInt : ints) {
            System.out.print(" "+anInt);
        }
    }

ps:一共冒泡了nums.length-1轮

            /*
             * TODO:优化1，减少内层循环的比较次数
             *  j < nums.length - 1 => j < nums.length - 1 - i
             * 每一轮都比上一轮少比较一次
             * 第一轮冒泡好了最后一个
             * 第二轮（第二轮不用冒泡最后一个）冒泡好了倒数第二个
             * 第三轮（第三轮不用冒泡倒数第二个）冒泡好了倒数第三个
             * ......以此类推
             */

            /*
             * TODO:优化2，减少外层的冒泡次数
             *  某些情况下，通常不需要冒泡完毕数组就已经有序
             * 添加代表有序的标识，默认是有序
             * 经过交换就变为无序
             * 如果经过一轮冒泡仍然是有序说明上一轮已经有序了
             * 即可以停止循环
             */

            /*
             * TODO:优化3，进一步减少内层的冒泡次数
             * 类似 {1, 56, 3, 85, 12, 34, 160, 189}数据，通常第一次冒泡完毕有两条数据已经符合条件了，所以下一次可以直接冒泡{1, 56, 3, 85, 12, 34}
             *使用变量保存最后一次交换的下标，下一次循环的终止条件就是这个下标
             */

最终版代码：

/**
     * 给定数组返回升序排列
     * 原理：相邻两两对比，不符合就交换位置
     * @param nums
     * @return
     */
    public int[] bubbleSort(int[] nums){


        /*
         * 记录最后一次交换的次数作为内层终止条件
         */
        int lastSwapIndex = nums.length - 1;

        for (int j = 0; j < nums.length - 1; j++) {

            /*
             * 存在循环中，就已经排好序的情况，这样的话就不用在循环
             * 如果没有发生交换就说明已经排好序了
             */
            boolean isOrdered = true;

            // 记录最后一次的下标
            int lastIndex = 0;

            /*
             * 使用 nums.length - 1 要不然 nums[i+1] 会下标越界
             * 每一层冒泡都会沉下去一个，所以最后j个是不用进行交换的
             */
            for (int i = 0; i < lastSwapIndex; i++) {

                if (nums[i] > nums[i+1]){
                    // 交换
                    int temp = nums[i];
                    nums[i] = nums[i+1];
                    nums[i+1] = temp;
                    isOrdered = false;
                    lastIndex = i;
                }

                System.out.println("第" + (j + 1) + "轮冒泡,"+"第"+(i + 1)+"轮交换" + Arrays.toString(nums));
            }
            // 在内层循环结束之后，将最后一次交换的下标赋值给内层终止条件
            lastSwapIndex = lastIndex;
            // 如果数组已经有序，那么终止外层循环
            if (isOrdered) {
                break;
            }
        }

        return nums;
    }

    @Test
    public void bubbleSortTest(){
        int[] nums = {1,56,3,85,12,34,97,2,-89,4,33,77,66,22,11,0};
        int[] ints = bubbleSort(nums);
        for (int anInt : ints) {
            System.out.print(" "+anInt);
        }
    }