冒泡排序算法(代码实现) [数据结构][Java]

冒泡排序算法(代码实现)

为了容易理解: 我们先将冒泡排序的过程分成一步一步进行分析,最后我们再归纳为一个双层的for循环

这里我们先进行一步一步的分析:(我们以一个方法的形式先给出代码)

/**
     * 一步一步对冒泡排序的推演
     */
    public static void bubbleSort(){
        //定义了一个长度为5的数组
          //对于这个长度为5的数组我们进行冒泡排序要进行排序4趟
        int arr[] = {3,9,-1,10};

        /*
        第一趟排序,也就是将最大的数排到最后的位置
         */

        //定义一个临时变量,用于两个位置的数值进行交换时使用
        int temp = 0;

        /*
        在第一趟中我们要执行数组长度减-1次
         */
        for (int j = 0; j < arr.length - 1 - 0; j++) {
            //如果前面的数比后面的数大,则交换位置
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第一趟排序之后的结果
        System.out.println("第一趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第二趟排序,也即是将第二大的元素排到倒数第二个位置上
         */
        //这里就不用重复的定义一个临时变量了

        //注意: 由于我们第一趟中已经将我们的数组中的最后一个位置排好了,这个时候第二趟排序我们只需要排序除过最后一个元素的其他位置的元素就可以了
        for(int j =  0; j < arr.length - 1 - 1; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第二趟排序之后的结果
        System.out.println("第二趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第三趟排序: 将第三大的数排到数组中倒数第三个位置上
         */

        for(int j = 0; j < arr.length - 1 - 2; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第三趟的排序结果
        System.out.println("第三趟的排序结果: ");
        System.out.println(Arrays.toString(arr));
    }

将冒泡排序总结为一个双层for循环(以方法的形式给出代码)

/**
     * 将冒泡排序归纳为一个双层for循环
     */
    public static void bubbleSort(int [] arr){
        //定义一个临时变量用于我们对两个位置上的元素的值进行交换
        int temp = 0;

        //定义外层for循环,控制冒泡排序执行的趟数
        for (int i = 0; i < arr.length - 1; i++) {
            //定义内存for循环,控制冒泡排序每趟执行的次数
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
//            System.out.println("第"+(i+1)+"趟冒泡排序的结果是");
//            System.out.println(Arrays.toString(arr));
        }
    }

我们将这两个方法都封装到了我们的自定义工具类ArraySort类中,下面我们给出ArraySort类

package com.ffyc.util;

import java.util.Arrays;

/**
 * 数组排序的一个工具类(内部封装了很多排序的方法(八种内部排序都封装在里面))
 */
public class ArraySort {
    /**
     * 一步一步对冒泡排序的推演
     */
    public static void bubbleSort(){
        //定义了一个长度为5的数组
          //对于这个长度为5的数组我们进行冒泡排序要进行排序4趟
        int arr[] = {3,9,-1,10};

        /*
        第一趟排序,也就是将最大的数排到最后的位置
         */

        //定义一个临时变量,用于两个位置的数值进行交换时使用
        int temp = 0;

        /*
        在第一趟中我们要执行数组长度减-1次
         */
        for (int j = 0; j < arr.length - 1 - 0; j++) {
            //如果前面的数比后面的数大,则交换位置
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第一趟排序之后的结果
        System.out.println("第一趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第二趟排序,也即是将第二大的元素排到倒数第二个位置上
         */
        //这里就不用重复的定义一个临时变量了

        //注意: 由于我们第一趟中已经将我们的数组中的最后一个位置排好了,这个时候第二趟排序我们只需要排序除过最后一个元素的其他位置的元素就可以了
        for(int j =  0; j < arr.length - 1 - 1; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第二趟排序之后的结果
        System.out.println("第二趟排序之后: ");
        System.out.println(Arrays.toString(arr));

        /*
        第三趟排序: 将第三大的数排到数组中倒数第三个位置上
         */

        for(int j = 0; j < arr.length - 1 - 2; j++){
            if(arr[j] > arr[j+1]){
                temp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = temp;
            }
        }

        //显示第三趟的排序结果
        System.out.println("第三趟的排序结果: ");
        System.out.println(Arrays.toString(arr));
    }

    /**
     * 将冒泡排序归纳为一个双层for循环
     */
    public static void bubbleSort(int [] arr){
        //定义一个临时变量用于我们对两个位置上的元素的值进行交换
        int temp = 0;

        //定义外层for循环,控制冒泡排序执行的趟数
        for (int i = 0; i < arr.length - 1; i++) {
            //定义内存for循环,控制冒泡排序每趟执行的次数
            for (int j = 0; j < arr.length - 1 -i; j++) {
                if(arr[j] > arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
//            System.out.println("第"+(i+1)+"趟冒泡排序的结果是");
//            System.out.println(Arrays.toString(arr));
        }
    }
}

我们给出两种方式的测试代码:

package com.ffyc.util.arraysorttest;

import com.ffyc.util.ArraySort;
import org.junit.Test;

import java.util.Arrays;

public class BubbleSortTest {
    //对一步一步执行的冒泡排序的测试
    @Test
    public void test1(){
        ArraySort.bubbleSort();
    }

    //对我们彻底归纳好的冒泡排序进行测试
    @Test
    public void test2(){
        int [] arr = {3,9,-1,10};
        System.out.println("排序前的数组为: ");
        System.out.println(Arrays.toString(arr));

        //调用我们编写好的冒泡排序算法进行排序
        ArraySort.bubbleSort(arr);

        System.out.println("排序后的数组为: ");
        System.out.println(Arrays.toString(arr));
    }
}