常用的一些小排序算法之冒泡排序，直接选择排序，反转排序

前言

常常会被问一些排序算法，可能对于客户端开发来说，直接用到的地方不多，即便是用到了也可以直接调用sort()方法，如下：

//通过数组帮助类Arrays来实现
    System.out.print("排序后数字：");
        //创建乱序数组
        int[] array ={1,3,9,4,3,6,7,5};
        //调用系统自带排序
        Arrays.sort(array);
        System.out.print("排序后数字：");
        for (int i:array){
            System.out.print(i);
        }

但是一些比较常见的基本排序算法还是有必要掌握一下，像冒泡

冒泡排序

冒泡排序的基本思想是：对比相邻的元素值，如果满足条件就交换元素的位置，通过双层遍历一直判断、交换位置，这样最小的元素就像冒泡一样上升到顶部了，冒泡排序也由此而来。代码如下：

 /**
     * 冒泡排序
     * 比如对数组60、3、20、2、4、15进行排序
     * 通过双循环两两比较
     * 第一层第一次：3、60、20、2、4、14
     * 第一层第二次：3、20、60、2、4、14
     * 第一层第三次：3、20、2、60、4、15
     * .....
     * 直到最后：2、3、4、15、20、60
     */
    public void sort(int[] array) {
        for (int i = 1; i < array.length; i++) {
            //比较相临的俩个元素，大值向后
            for (int j = 0; j < array.length - i; j++) {//每轮排序完长度减-1
                if (array[j] > array[j + 1]) {//如果前面一个值大于后面对值
                    int temp = array[j];//把第一个元素值保存到一个临时变量用来交换
                    array[j] = array[j + 1];//交换前后值
                    array[j + 1] = temp;//给j+1赋值
                }
            }
        }

        for (int i : array) {
            System.out.print(">" + i);
        }

    }

最终结果:

直接选择排序

直接选择排序也是排序的一种，他的思想是：将指定的排序位置与其他数组元素分别对比，如果满足条件就交换元素值，不同与冒泡的交换相邻元素，而是把满足条件的元素与指定的排序位置交换，代码如下：

public void sort01(int[] array) {
        /**
         * 直接选择排序
         * 比如数组：60、4、20、1、3、5
         * 第一次排序：（5、4、20、1、3）、60 //可以看到直接交换5和60的位置，因为60最大所以在最后；括号内表示需要排序的值
         * 第二次排序：（5、4、3、1）、20、60
         * 第三次排序：（1、4、3）、5、20、60
         * 第四次排序：（1、3）、4、5、20、60
         * 第五次排序：（1）、3、4、5、20、60//排序完成
         */

        int index;//最大值的下标
        for (int i = 1; i < array.length; i++) {
            index = 0;
            for (int j = 1; j <= array.length - i; j++) {
                if (array[j] > array[index]) {
                    index = j;//获取最大值的下标
                }
            }
            //交换下标 array.length-i和index上的两个值
            int temp = array[array.length - i];//把要交换的值保存到临时变量中（因为它的位置的值是小于index的）
            array[array.length - i] = array[index];//重新赋值（下标越大值越大）
            array[index] = temp;//index下标拿到交换的值
        }

        for (int i : array) {
            System.out.print(">" + i);
        }
    }

最终结果如下

反转排序

反转排序其实就是把原来的数据顺序反过来排，反转排序是对数组两边的元素进行替换，所以只需要循环数组长度的半次，代码如下：

  public void sort02(int[] array) {
        /**
         * 反正排序
         * 比如数组：60、4、20、1、3、5
         * 第一次：5、（4、20、1、3）、60//括号内表示需要反转的数
         * 第二次：5、3、（20、1）、4、60
         * 第三次：5、3、1、20、4、60//完成反转
         */
        System.out.println("交换前值：");
        for (int i : array) {
            System.out.print("\t" + i);
        }


        int temp;
        int len = array.length;//获取数组下标
        for (int i = 0; i < len / 2; i++) {//两两对换故只要一半
            temp = array[i];//用于交换值的临时变量
            array[i] = array[len - 1 - i];//下标从0开始所以要减1
            array[len - 1 - i] = temp;//交换后取temp拿到array[i]原来值
        }

        System.out.println();
        System.out.println("交换后值:");
        for (int i : array) {
            System.out.print("\t" + i);
        }
    }

结果如下:
以上是3个简单而用常用小算法，自己都手敲了一遍，并且加上注释来帮助自己记忆和理解，后面遇到的，再补充进来，慢慢积累！