插入排序

1,插入排序，前面有序，后面无序，因此从第个开始算起，比较前面一个，比他小，移动位置
N为当前指向，向前比较，4<5,替换位置

N为当前指向，向前比较，4<5,替换位置，N指向下一个，目前4，5是有序的

2向前比较，2<5,替换位置

2继续向前比较，2<5,替换位置，2继续向前比较，2<4, 替换位置

目前2，4，5是有序的，N指针指向数字3

3向前比较，3<5替换位置

3继续向前，3<4,替换位置

3继续向前，3>2,不用替换位置，2，3，4，5有序，N指针指向下一个

8向前比较，8>5，不用替换

代码展示

插入排序，前面有序，后面无序，向前面右比较

位置2，向前比较，第一次循环(内部循环)，向前走，替换位置，比较前面，如果大于它本身的数，则进行替换，N指针是保持不变的。替换位置后aim需要跟新最新位置

package com.my;

/**
 * 插入排序，前面有序，后面无序，向前面比较
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] ints = new int[]{5,4,2,3,8};


        int N = 1;
        int aim = N;

        for(int i = aim-1;i<N;N--){//向前比较
            if(ints[i]>ints[aim]){
                //aim换完后，aim=i 新位置
                swap(ints,i,aim);
                aim = i;
            }
        }


        print(ints);

    }

    public static void swap(int[] ints,int a,int b){
        int temp = ints[a];
        ints[a] = ints[b];
        ints[b] = temp;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}

45238

以此类推，外面嵌套循环，N指针for循环递增

package com.my;

/**
 * 插入排序，前面有序，后面无序，向前面比较
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] ints = new int[]{5,4,2,3,8};
        int N = 1;
        for(int o=N;o<ints.length;o++){
            int aim = o;
            for(int i = aim-1;i<o&&i>=0;i--){//向前比较
                if(ints[i]>ints[aim]){
                    //aim换完后，aim=i 新位置
                    swap(ints,i,aim);
                    aim = i;
                }
            }
        }
        print(ints);

    }

    public static void swap(int[] ints,int a,int b){
        int temp = ints[a];
        ints[a] = ints[b];
        ints[b] = temp;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}

23458

这里的N有点多余，优化掉

package com.my;

/**
 * 插入排序，前面有序，后面无序，向前面比较
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] ints = new int[]{5,4,2,3,8};
        for(int o=1;o<ints.length;o++){
            int aim = o;
            for(int i = aim-1;i<o&&i>=0;i--){//向前比较
                if(ints[i]>ints[aim]){
                    //aim换完后，aim=i 新位置
                    swap(ints,i,aim);
                    aim = i;
                }
            }
        }
        print(ints);

    }

    public static void swap(int[] ints,int a,int b){
        int temp = ints[a];
        ints[a] = ints[b];
        ints[b] = temp;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}

继续优化，if循环可以放在for循环里面判断

package com.my;

/**
 * 插入排序，前面有序，后面无序，向前面比较
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] ints = new int[]{5,4,2,3,8};
        for(int o=1;o<ints.length;o++){
            int aim = o;
            for(int i = aim-1;i<o&&i>=0 && ints[i]>ints[aim];i--){//向前比较
                //aim换完后，aim=i 新位置
                swap(ints,i,aim);
                aim = i;
            }
        }
        print(ints);

    }

    public static void swap(int[] ints,int a,int b){
        int temp = ints[a];
        ints[a] = ints[b];
        ints[b] = temp;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}

这里aim参数可以优化掉，有点多余，参数i一直可以往前走，不担心找不到aim的位置，而且比较都是往前一个比较的，因此判断语句可以优化成ints[i]<ints[i-1]

package com.my;

/**
 * 插入排序，前面有序，后面无序，向前面比较
 */
public class InsertionSort {

    public static void main(String[] args) {
        int[] ints = new int[]{5,4,2,3,8};
        for(int o=1;o<ints.length;o++){
            for(int i = o;i>0 && ints[i]<ints[i-1];i--){//向前比较
                swap(ints,i,i-1);
            }
        }
        print(ints);

    }

    public static void swap(int[] ints,int a,int b){
        int temp = ints[a];
        ints[a] = ints[b];
        ints[b] = temp;
    }

    public static void print(int[] ints){
        for(int i:ints){
            System.out.print(i);
        }
    }
}