冒泡排序算法详解(从后往前)

冒泡排序算法详解(从后往前)

A. 从最后一个元素开始进行两两比较,保证第i位置的上是最小的------升序

1.核心代码

for (int i = 0; i <numbers.length-1; i++) {
    for (int j =numbers.length-1;j>i; j--) {
         //从最后一个元素开始,进行两两比较
        // 后者(开始位置)比前者小就交换,保证最小的数都交换到了第i个位置上去了
         if(numbers[j]<numbers[j-1]){
             int temp=numbers[j];
             numbers[j]=numbers[j-1];
             numbers[j-1]=temp;
         }
     }
}

2.常见问题点分析

2.1 如何进行冒泡排序???

目的:每次两两交换完后,保证第i个位置是最小值

解决方案: 1.从第(数组长度-1-i)个元素开始(初始为尾元素),每次与后面的元素两两比较

​ 2.若后者小于前者,则进行值的交换,否则进入下一次循环操作

​ 3.当两两交换到第一个位置(下标为0)的数时,本次交换结束

​ 下一次两两交换的范围缩短1,然后进行下一轮两两比较

​ 当执行完(数组长度-1)轮两两比较时,冒泡排序算法才执行结束

2.2 冒泡排序的循环次数为多少?

解决方案:循环次数=数组长度-1

2.3 冒泡排序具体操作(数字是这么移动的)过程

以数组int[] a=[9,-8,3,7,6]为例

排序次数	需要排序的数组部分	排序前的数组	排序后的数组
第1次	[9,-8,3,7,6]	[9,-8,3,7,6]	[-8,9,3,6,7]
第2次	[9,3,6,7]	[-8,9,3,6,7]	[-8,3,9,6,7]
第3次	[9,6,7]	[-8,3,9,6,7]	[-8,3,6,9,7]
第4次	[9,7]	[-8,3,6,9,7]	[-8,3,6,7,9]

2.4 为什么内层循环的判定条件为 就j>i

理由:1.每两两交换一轮,范围缩小1

​ 2.从后往前进行两两交换

​ 3.两两交换开始位置为最后一个

2.5 为啥条件numbers[j]<numbers[j-1]满足时,要进行两两交换?

解答: 每交换一次时,使得两者之中的较小值往前移动一格

​ (这样小数都会往前移动了—>直到遇见比之还小的数字就终止移动)

​ 这样能在每轮两两交换完成后,最小值的下标为i

2.6 两两交换一轮为多少次?

假设需要排序的数组长度为5,每次都符合交换条件

​ 当需要把最小值移动到第1个位置(下标0)时,需要两两交换4次

​ 当需要把最小值移动到第2个位置(下标1)时,需要两两交换3次

​ 当需要把最小值移动到第3个位置(下标2)时,需要两两交换2次

​ 当需要把最小值移动到第4个位置(下标3)时,需要两两交换1次

​ 此时冒泡结束

​ 因而每一轮两两交换次数=数组长度-1-i

3.运行截图

4.源代码

public class BubSort03 {
    public static void main(String[] args) {
        System.out.println("冒泡排序(从后往前)-----升序");
        int[] numbers={9,-8,3,7,6};
        System.out.println("排序前");
        for (int temp01:numbers
        ) {
            System.out.print(temp01+"\t");
        }
        for (int i = 0; i <numbers.length-1; i++) {
            for (int j =numbers.length-1;j>i; j--) {
                //从最后一个元素开始,进行两两比较
                // 后者(开始位置)比前者小就交换,
                //保证最小的数都交换到了第i个位置上去了
                if(numbers[j]<numbers[j-1]){
                    int temp=numbers[j];
                    numbers[j]=numbers[j-1];
                    numbers[j-1]=temp;
                }
            }
            System.out.println("\n第"+(i+1)+"次排序结果为:");
            for (int temp02:numbers
            ) {
                System.out.print(temp02+"\t");
            }
        }
        System.out.println("\n冒泡排序的最终结果为: ");
        for (int temp03:numbers
        ) {
            System.out.print(temp03+"\t");
        }
    }
}

B. 从最后一个元素开始进行两两比较,保证第i位置的上是最大的------降序

1.核心代码

for (int i = 0; i <numbers.length-1; i++) {
     for (int j =numbers.length-1;j>i; j--) {
         //从最后一个元素开始,进行两两比较
        // 后者(开始的位置)比前者大就交换
        //保证最大的数都交换到了第i个位置上去了
        if(numbers[j]>numbers[j-1]){
            int temp=numbers[j];
            numbers[j]=numbers[j-1];
            numbers[j-1]=temp;
         }
       }
}

2.常见问题点分析

2.1 如何进行冒泡排序???

目的:每次两两交换完后,保证第i个位置是最大值

解决方案: 1.从第(数组长度-1-i)个元素开始(初始为尾元素),每次与后面的元素两两比较

​ 2.若后者大于前者,则进行值的交换,否则进入下一次循环操作

​ 3.当两两交换到第一个位置(下标为0)的数时,本次交换结束

​ 下一次两两交换的范围缩短1,然后进行下一轮两两比较

​ 当执行完(数组长度-1)次两两比较时,冒泡排序算法才执行结束

2.2 冒泡排序的循环次数为多少?

解决方案:循环次数=数组长度-1

2.3 冒泡排序具体操作(数字是这么移动的)过程

以数组int[] a=[4,8,6,22,23]为例

排序次数	需要排序的数组部分	排序前的数组	排序后的数组
第1次	[4,8,6,22,23]	[4,8,6,22,23]	[23,4,8,6,22]
第2次	[4,8,6,22]	[23,4,8,6,22]	[23,22,4,8,6]
第3次	[4,8,6]	[23,22,4,8,6]	[23,22,8,4,6]
第4次	[4,6]	[23,22,8,4,6]	[23,22,8,6,4]

2.4 为什么内层循环的判定条件为 就j>i

理由:1.每两两交换一轮,范围缩小1

​ 2.从后往前进行两两交换

​ 3.两两交换首轮开始位置为最后一个

2.5 为啥条件numbers[j]>numbers[j-1]满足时,要进行两两交换?

解答: 每交换一次时,使得两者之中的较大值往前移动一格

​ (这样大数都会往前移动了—>直到遇见比之还大的数字就终止移动)

​ 这样能在每轮两两交换完成后,最大值的下标为i

2.6 两两交换一轮为多少次?

假设需要排序的数组长度为5,每次都符合交换条件

​ 当需要把最大值移动到第1个位置(下标0)时,需要两两交换4次

​ 当需要把最大值移动到第2个位置(下标1)时,需要两两交换3次

​ 当需要把最大值移动到第3个位置(下标2)时,需要两两交换2次

​ 当需要把最大值移动到第4个位置(下标3)时,需要两两交换1次

​ 此时冒泡结束

​ 因而两两交换次数=数组长度-1-i

3.运行截图

4.源代码

public class BubSort04 {
    public static void main(String[] args) {
        System.out.println("冒泡排序(从后往前)-----降序");
        int[] numbers={4,8,6,22,23};
        System.out.println("排序前");
        for (int temp01:numbers
        ) {
            System.out.print(temp01+"\t");
        }
        for (int i = 0; i <numbers.length-1; i++) {
            for (int j =numbers.length-1;j>i; j--) {
                //从最后一个元素开始,进行两两比较
                // 后者(开始的位置)比前者大就交换,保证最大的数都交换到了第i个位置上去了
                if(numbers[j]>numbers[j-1]){
                    int temp=numbers[j];
                    numbers[j]=numbers[j-1];
                    numbers[j-1]=temp;
                }
            }
            System.out.println("\n第"+(i+1)+"次排序结果为:");
            for (int temp02:numbers
            ) {
                System.out.print(temp02+"\t");
            }
        }
        System.out.println("\n冒泡排序的最终结果为: ");
        for (int temp03:numbers
        ) {
            System.out.print(temp03+"\t");
        }
    }
}