数据结构算法【2】选择排序、冒泡排序、插入排序

选择排序，冒泡排序，插入排序   一个数组长度为 N ，把他从小到大排序

选择排序： 

1. 直接从整个数组中找到最小的一个数，和0位置交换位置；
2. 排除0位置（0位置肯定是最小的了），从1~N位置查找最小数字，和1位置数交换位置。
3. 排除0，1位置，从2 ~ N 位置查找最小数字，并把最小数字和2位置交换，以此类推
4. 选择排序是先找出小的数，放在最前排，后续排序忽略前面已排好序的位置。

冒泡排序： 

1. 两两比较，0和1位置比较，谁大往后移，1和2比较，谁大往后移，那么到最后N-1和N位置数比较，谁大往后移，第N个位置的肯定是最大的数。
2. 排除掉第N位置的数，还是从0和1开始两两比较，谁大往后移，一直到 N-2和N-1位置的数比较，谁大往后移。以此类推。
3. 冒泡排序特点是先选出最大的数，放在末尾；

插入排序：⭐

        0 ~ N 范围做到有序，

        1. 先 0~0位置做到有序，然后 0~1 ，0~2，0~3 位置做到有序，两个位置间的数做比较，小的数挪到左边，交换位置。一直比到0位置，或者比较到左边的数字不比这个数大了，就停住了。

---

选择排序

package com.example.algorithm.class01;


public class SelectSort {

    static int[] arr = {5,7,6,1,3,3,8,4,2,5,3,8};

    /**
     * 1. 直接从整个数组中找到最小的一个数，和 0 位置交换位置；
     * 2. 排除0位置（0位置肯定是最小的了），从1~N位置查找最小数字，和1位置数交换位置。
     * 3. 排除0，1位置，从2 ~ N 位置查找最小数字，并把最小数字和2位置交换，以此类推
     *
     * 用代码解释以上内容：
     * 1. 用 0 位置数和所有数组中所有剩下的数作比较，最小的数和 0 位置的数交换位置
     * 2. 用 1 位置数和所有数组中所有剩下的数作比较，最小的数和 1 位置的数交换位置
     * 3. 以此类推...
     */

    public static void main(String[] args) {
        print();
        select();
        print();
    }

    /**
     * 选择排序
     */
    public static void select(){
        if(arr == null || arr.length < 2){
            return ;
        }
        int n = arr.length;
        /**
         * 0 ~ n-1 间选择一个最小的数
         * 1 ~ n-1 间选择一个最小的数
         * 2 ~ n-1 间选择一个最小的数
         */
        for(int i = 0;i <= n-1  ; i++){ //管一个范围
            int minValueIndex = i;
            /**
             * 0 ~ n-1 间选择一个最小的数
             * i ~ n-1 间选择一个最小的数
             */
            for(int j = i+1;j<n;j++){
                if(arr[j] < arr[minValueIndex]){
                    swap(j,minValueIndex);
                }
            }

        }
    }

    private static void swap(int old, int replace) {
        int tmp = arr[old];
        arr[old] = arr[replace];
        arr[replace] = tmp;
    }

    // 打印数组
    public static void print(){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
        System.out.println();
    }

}

冒泡排序

package com.example.algorithm.class01;


public class BubbleSort {

    static int[] arr = {5,7,6,1,3,9,8,4,2,5,3,8};

    /**
     * 1. 两两比较，0和1位置比较，谁大往后移，1和2比较，谁大往后移，那么到最后N-1和N位置数比较，谁大往后移，第N个位置的肯定是最大的数。
     * 2. 排除掉第N位置的数，还是从0和1开始两两比较，谁大往后移，一直到 N-2和N-1位置的数比较，谁大往后移。以此类推。
     * 冒泡排序特点是先选出大的数，放在末尾；
     *
     * 用代码解释以上内容：
     * 1. 先选定范围（for循环），
     * 2. 在这个范围内做for循环排序，这个排序就是两两比较： 0~1比较，1~2比较，N-1 ~ 比较
     * 3. 以此类推...
     */

    public static void main(String[] args) {
        print();
        Bubble();
        print();
    }

    /**
     * 选择排序
     */
    public static void Bubble(){
        if(arr == null || arr.length < 2){
            return ;
        }
        int n = arr.length;
        /**
         * 0 ~ n-1 间选择一个最小的数
         * 0 ~ n-2 间选择一个最小的数
         * 0 ~ n-3 间选择一个最小的数
         */
        for(int i = n-1;i >=0  ; i--){ //管一个范围
            int maxValueIndex = i;

            //做具体的事情
            //两两比较 0~1 ， 1~2 ， 2~3 ， N-1和 N
            for(int j = 0 ; j <= i-1; j++){
                if( arr[j] >  arr[j+1]){
                   swap(j,j+1);
                }
           }
        }
    }

    private static void swap(int old, int replace) {
        int tmp = arr[old];
        arr[old] = arr[replace];
        arr[replace] = tmp;
    }

    // 打印数组
    public static void print(){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
        System.out.println();
    }

}

插入排序 ： 

package com.example.algorithm.class01;

/**
 * 插入 排序
 */
public class InsertSort {

    static int[] arr = {5,7,6,1,3,9,8,4,2,5,3,8};

    /**
     * 1. 两两比较，0和1位置比较，谁大往后移，1和2比较，谁大往后移，那么到最后N-1和N位置数比较，谁大往后移，第N个位置的肯定是最大的数。
     * 2. 排除掉第N位置的数，还是从0和1开始两两比较，谁大往后移，一直到 N-2和N-1位置的数比较，谁大往后移。以此类推。
     * 冒泡排序特点是先选出大的数，放在末尾；
     *
     * 用代码解释以上内容：
     * 1. 先选定范围（for循环），
     * 2. 在这个范围内做for循环排序，这个排序就是两两比较： 0~1比较，1~2比较，N-1 ~ 比较
     * 3. 以此类推...
     */

    public static void main(String[] args) {
        print();
        insert();
        print();
    }

    /**
     * 插入 排序
     */
    public static void insert(){
        if(arr == null || arr.length < 2){
            return ;
        }
        int n = arr.length;

        /**
         * 0 ~ 0 完成有序
         * 0 ~ 1 完成有序
         * 0 ~ 2 完成有序
         * 0 ~ 3 完成有序
         * 0 ~ n-1 完成有序
         */
        for(int i = 1;i < n ; i++){ //管一个范围
            // 这个就是要比较的数；假设i=5，那么0~4都已经做到了有序排序，就要用第5位来和0~4位置的数作比较，
            // 第5位的数和第4位的数作比较，所以就是 i 和 i-1位置的数比较
            int CunrretnValueIndex = i;
            /**
             *     CunrretnValueIndex -1 >=0    代表左边已经没有数了。
             *     arr[CunrretnValueIndex -1 ] > arr[CunrretnValueIndex]     i 和 i-1位置的数 ，  i-1 位置大于 i 位置（第4位置数大于第5位置数），
               那就需要交换位置，
             * 当前（5和4）比较完后，就需要往前推一步，然后就是第4位置数和第3位置数做比较，所以需要 CunrretnValueIndex-- ，
               直到 CunrretnValueIndex -1 不大于0，就表示到边界了，左边没有数了，
             */
          while(CunrretnValueIndex -1 >=0 && arr[CunrretnValueIndex -1 ] > arr[CunrretnValueIndex]){
              swap(CunrretnValueIndex-1 ,CunrretnValueIndex);
              CunrretnValueIndex--;
          }
        }
    }

    private static void swap(int old, int replace) {
        int tmp = arr[old];
        arr[old] = arr[replace];
        arr[replace] = tmp;
    }

    // 打印数组
    public static void print(){
        for(int i = 0;i<arr.length;i++){
            System.out.print(arr[i]);
        }
        System.out.println();
    }

}