Java实现冒泡排序、选择排序及详解

冒泡排序

原理

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2. 对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3. 针对所有的元素重复以上的步骤，除了最后一个。
4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

相当于，每次循环（使用循环，找出最大的一个数字，排到末尾）

就像冒泡泡一样，每次把最大的泡泡冒到最上面

代码实现

package sort;

public class BubblingSort {
    public static void main(String[] args) {
        int[] array = {2, 3, 4, 1, 6, 5};
        BubblingSort sort = new BubblingSort();
        int[] ints = sort.bubblingSort(array);
        for (int anInt : ints) {
            System.out.print(anInt+ " ");
        }
    }
    public int[] bubblingSort(int[] array){
        int a;//中间变量，用于交换两个变量的值
        /*
        * 这里i 从array.length-1开始，是防止array[j+1]的时候数组下标越界
        * 每次循环的范围比上一次小一个，因为内部循环每循环一次，
        * 这次循环中最大的数字都在当前循环数字的范围内的最后一位
        * 即内部循环 第一次为：找出数组中所有数字的最大值，放到数组末尾
        * 第二次为：找出除数组末尾（上次循环的最大数字）外的最大数字，放到本次循环的数字的最后一位（倒数第二）
        * 依次循环，直到i 为 0
        * */
        for (int i = array.length-1; i >= 0 ; i--) {
            for (int j = 0; j < i; j++) {
                if (array[j] > array[j+1] ){
                    a = array[j+1];
                    array[j+1] = array[j];
                    array[j] = a;
                }
            }
        }
        return array;
    }
}

思考与优化

上述代码你会发现，就算是已经排好或者中途就排好了的数组，还是会继续循环

这种情况下就可以直接跳出循环，输出结果

所以我们可以在第二层循环外，定义一个boolean flag = false；，如果本次内部循环发生过变量交换，则flag =true，否则 即本次循环没有发生过任何一次变量交换，即本次循环的数字，后一个都比前一个大，这样接下来的循环就没有意义，可以直接跳出循环。

优化后的代码

public int[] bubblingSort(int[] array){
    int a;
    boolean flag = false;
    for (int i = array.length-1; i >= 0 ; i--) {
        for (int j = 0; j < i; j++) {
            if (array[j] > array[j+1] ){
                a = array[j+1];
                array[j+1] = array[j];
                array[j] = a;
                flag = true;
            }
        }
        if (!flag){ //如果本次循环没有发生变量位置交换，说明已经排好了，可以直接break
            break;
        }else { //如果发生了，则要重置flag的值，防止flag一直==true，这样后面哪一次没有交换就不会break
            flag = false;
        }
    }
    return array;
}

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

简而言之，就是挑选出最小的值，与第一个元素交换位置。第二次则从第二个元素开始，挑出最小的值，与第二个元素交换位置。

与冒泡排序有一点点像，但是冒泡排序是：只要前一个元素大于后一个元素就交换，会发生很多次交换

而选择排序每次只交换当前需要排序的数字中最小的元素，交换次数比较少

图源百度百科

实现思路

首先，需要一个变量 n 记录每次挑选出的最小的变量。

其次，需要一个变量 index 记录这个最小变量的下标，方便交换

实现代码

package sort;

public class ChooseSort {
    public static void main(String[] args) {
        //这里是随机生成了有长度 80k 的数组，用来比较排序算法的执行效率
        //我这台电脑性能比较差，用时 4s左右，而冒泡算法执行同样的数组，则需要20s
//        int[] array = new int[80000];
//        for (int i = 0; i < array.length; i++) {
//            array[i] = (int)(Math.random()*800000);
//        }
        int[] array = {2, 3, 2, 1};
        long startTime=System.currentTimeMillis();//开始排序的时间
        int[] ints = chooseSort(array);
        long endTime=System.currentTimeMillis();//结束排序的时间
        System.out.println("程序运行时间： "+(endTime - startTime)+"ms");//相减即为排序用时
        for (int anInt : ints) {
            System.out.print(anInt);
        }
    }

    public static int[] chooseSort(int[] array){
        int index;  //记录最小值的下标
        int n;      //记录找到的最小值
        //从0开始，每次++，是因为没循环一次，这次循环找到的最小值，都放在了数组下标j的位置，下次则不需要参与比较
        for (int j = 0; j < array.length; j++){
            //每次开始找最小值得时候，都重置一下，初始值为：这次需要循环的数字的最前端的值，和其下标
            index = j;      
            n = array[j]; 
            //让i从j开始循环，因为前面的数字都经过了筛选，不需要再对比
            for (int i = j; i < array.length; i++) {
                //每次当 当前值小于n的时候，让n保存它的值，用作下次对比
                if (array[i] < n){
                    n = array[i];
                    index = i;
                }
            }
            //循环结束，找到本次的最小值，与本次循环的最前端的数字交换位置
            array[index] = array[j];
            array[j] = n;
        }
        return array;
    }
}