直接插入排序

直接插入排序

算法思想：
1.从序列第一个元素开始，该元素可以认为已经被排好序。
2. 取出下一个元素，设为待插入元素，在已经排序的元素序列中从后向前扫描，如果该元素（已排序）大于待插入元素，将该元素移到下一位置。
3. 重复步骤2，直到找到已排序的元素小于或者等于待排序元素的位置，插入元素。
4. 重复2，3步骤，完成排序。
算法过程：

算法实现：

package com.bjsxt.sort;

import java.util.Arrays;

public class StraightInsertSort {

//方法一：
    public static void sort1(int[] a) {
        int i,j,k;
        //从下标1开始，将元素依次插入到前面的有序数列中
        for (i = 1; i <a.length; i++) {
            //寻找待插入位置
            for (j = 0; j < i; j++) {
                //找到就break
                if (a[i] < a[j]) {
                    break;
                }
            }
            //如果i==j，说明arr[i]大于前面所有已排序的元素，应该插
            //入到最末尾，也就是arr[i]自己的位置上,所以不需要处理

            if (i != j) {

                //保存待插入元素的值
                int key = a[i];
                //将从下标j开始向后挪位
                for (k = i; k > j; k--) {
                    a[k] = a[k - 1];
                }
                a[j] = key;
            }
        }
    }

    /*
    在方法一中，我们在查找待排序元素的插入位置时，是从前往后找的，这样会有一个缺点，即我们从下标0开始找，找到了
    合适的插入位置j，此时已经遍历了0-j，再到将j以后元素向后挪位时，正好遍历了一遍数组，这样即使原来i已经在其合适
    位置，仍会遍历数组，这不是我们想要的！
    因此我们要从后往前寻找i的插入位置。
     */

    //方法二：
    public static void sort2(int[] a) {
        int i,j;
        for (i = 0; i <a.length ; i++) {
            int temp=a[i];
            //寻找插入位置，找到后break
            for (j = i - 1; j >= 0; j--) {
                if (temp < a[j]) {
                    a[j + 1] = a[j];
                } else {
                    break;
                }
            }
            //这里j最小=-1,所以要让j+1=temp
            a[j+1]=temp;
        }
    }
/*
for循环里if语句的内容可以直接写到for语句的条件部分,即为方法三。
 */

//方法三：
    public static void sort3(int[] a) {
        int i,j;
        //依次将a[1]-a[a.length-1]插入到前面已排序序列
        for (i = 1; i <a.length; i++) {
                //用temp暂存a[i]
                int temp = a[i];
                //检查所有前面已排好序的元素
                for (j = i - 1; j >= 0 && a[j] > temp; j--) {
                    //所有大于temp的元素向后挪位
                    a[j + 1] = a[j];
                }
                //复制到插入位置
                a[j+1]=temp;
        }
    }

    //方法四：实现带哨兵的直接插入排序算法
    public static void sort4(int[] a) {
        int i,j;
        for (i = 2; i < a.length; i++) {
            if (a[i] < a[i - 1]) {
                a[0]=a[i];
                for (j = i - 1; a[j] > a[0]; j--) {
                    a[j+1]=a[j];
                }
                a[j+1]=a[0];
            }
        }
    }

    //从a[1]开始遍历，得到使用哨兵得到的排序序列
    public static void show(int[] a) {
        System.out.print("[");
        for (int i = 1; i <a.length ; i++) {
            System.out.print(a[i]+", ");
        }
        System.out.println("]");
    }

    public static void main(String[] args) {
        int[] arr={0,4,8,3,9,5,1};
        sort4(arr);
        show(arr);
//        System.out.println(Arrays.toString(arr));
    }
}

空间复杂度：O(1)
时间复杂度：O(n^2)
稳定性：稳定

参考：
带哨兵java实现插入排序和希尔排序