插入排序、希尔排序、冒泡排序

欢迎大家关注我的微信公众号：

什么是算法：
很多人一听到算法，就感觉高深莫测。
当然，算法需要不断的积累和练习，
但是大家也不要害怕，
其实算法，就是一种解决问题的思路，
当你熟悉它，也许你会爱上它~

话不多说，直接来干货。
说到算法排序，有很多，我们慢慢讲。

我们先来看看插入排序：
插入排序：对一个有序的有序的序列插入，插入进去后保证还是有序的。

看代码：

package com.monkey.springdemo.utils.sort;
/**
 * 插入排序
 */
public class InsertSort {

    public static void main(String[] args) {

        /**
         * 插入序列 1 4 3 2 5
         * 第一步：插入1
         * 第二步：插入4，排序得到1 4
         * 第三步：插入3，排序得到1 3 4
         * 第四步：插入2，排序得到1 2 3 4
         * 第五步：插入5，排序得到1 2 3 4 5
         */
        int data[] = {1,4,3,2,5};
        for (int i = 0, n = data.length; i < n; i++){  //首次加进来的数
            for (int j = i;j > 0; j--){    //j表示已经排好序的序列
                if(data[j] < data[j-1]){    //与前一个值比较，将较小的值移到前面
                    /**
                     * 数值交换：
                     * 定义第三个变量：
                     */
                    /*int temp = data[j];
                    data[j] = data[j-1];
                    data[j-1] = temp;*/
                    /**
                     * 数值交换：
                     * a = a + b;
                     * b = a - b;
                     * a = a - b;
                     */
                    data[j] = data[j] + data[j-1];
                    data[j-1] = data[j] - data[j-1];
                    data[j] = data[j] - data[j-1];
                }else {
                    break;
                }
            }
        }

        for (int i = 0, n = data.length; i < n; i++){
            System.out.print(data[i] + " ");
        }

    }
}

好，说完插入排序，我们再来看看希尔排序：
希尔排序：是插入排序的升级，它有一个步长分组的概念。目的就是为了减少判断的次数。

package com.monkey.springdemo.utils.sort;
/**
 * 希尔排序
 */
public class ShellSort {

    /**
     *  数组1 4 3 2 5，假设取步长为2
     *  第一步，step = len/2 = 5/2 = 2;
     *          1 3 => 分出来的再进行一个插入排序 => 1 3
     *          4 2 => 2 4
     *          5   => 5
     *          所以第一步结束后，序列变成了1 2 3 4 5
     *  第二步，step = step/2 = 1 (步长最短为1，所以step=1后排序结束)
     *          第二步结束后，序列变成了1 2 3 4 5
     */
    public static void main(String[] args) {
        int data[] = {1,4,3,2,5};
        int step = data.length;
        while (step >= 1){
            step = step / 2;
            for (int i = step, n = data.length; i < n; i++){
                for (int j = i; j - step >= 0; j = j - step){
                    if(data[j] < data[j-step]){
                        data[j] = data[j] + data[j-step];
                        data[j-step] = data[j] - data[j-step];
                        data[j] = data[j] - data[j-step];
                    }else{
                        break;
                    }
                }
            }
        }

        for (int i = 0,  n = data.length; i < n; i++){
            System.out.print(data[i] + " ");
        }
        
    }
}

最后，我们来看一看冒泡排序：
冒泡排序：就是两两比较，但不是跟所有人比较。
相信很多朋友对冒泡排序都有所了解。

上代码：

package com.monkey.springdemo.utils.sort;
import java.util.Scanner;
/**
 * 冒泡排序
 */
public class BubbleSort {

    public static void main(String[] args) {
        /*Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        int data[] = new int[n];
        for (int i = 0; i < n; i++){
            data[i] = cin.nextInt();
        }*/
        int data[] = {1,4,3,2,5};
        for (int i = 0, len = data.length; i < len; i++){
            for(int j = i ; j < len-1-i; j++){
                if(data[j] > data[j+1]){
                    data[j] = data[j] + data[j+1];
                    data[j+1] = data[j] - data[j+1];
                    data[j] = data[j] - data[j+1];
                }
            }
        }
        for (int i = 0, len = data.length; i < len; i++){
            System.out.print(data[i] + " ");
        }

    }
}

小伙伴们可以试一试，
debug去跑一跑，一定就可以理解了。