直接插入排序

直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的有序的表中，从而得到一个新的、记录数增1的有序表。
当前元素的前面元素均为有序，要插入时，从当前元素的左边开始往前找（从后往前找），比当前元素大的元素均往右移一个位置，最后把当前元素放在它应该呆的位置就行了
java代码实现：

方法一：

package Insertion;
public class Insertion {
    public static int[] insertion(int[] arr)
    {
        if(arr==null||arr.length<2)
        {
            return arr;
        }
        for(int i=1;i<arr.length;i++)
        {
            for(int j=i;j>0;j--)
            {
                if(arr[j]<arr[j-1])
                {
                    int temp=arr[j];
                    arr[j]=arr[j-1];
                    arr[j-1]=temp;
                }
                else
                {
                    break;  
                }
            }
            //下面一个for循环是为了看清楚插入排序的过程
            for(int k=0;k<arr.length;k++)
            {
                System.out.print(arr[k]+" ");
            }
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        int arr[]={1,5,3,4,5,59,10,2,13};
        int arr1[]=insertion(arr);
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }
    }
}

结果为：
1 5 3 4 5 59 10 2 13
1 3 5 4 5 59 10 2 13
1 3 4 5 5 59 10 2 13
1 3 4 5 5 59 10 2 13
1 3 4 5 5 59 10 2 13
1 3 4 5 5 10 59 2 13
1 2 3 4 5 5 10 59 13
1 2 3 4 5 5 10 13 59

1 2 3 4 5 5 10 13 59
方法二：
该算法是将搜索位置和移动元素分开

package Insertion;
public class Insertion1 {
    public static int[] insertion(int[] arr) 
    {
        int j, k;
        for (int i = 1; i < arr.length; i++) 
        {
            //为a[i]在arr[0]~arr[i-1]之间找一个插入位置   
            for (j = i - 1; j >= 0; j--)
            {
                if (arr[j] < arr[i])
            //因为arr[i]之前的元素都已经排好序了，所以假如到某个位置arr[j]<arr[i]
            //则说明arr[i]元素是位置目前就该在arr[j]之后,所以break跳出循环
                    break;
            }
            if (j != i - 1) {
                int temp = arr[i];//arr[i]为带插入元素,比它大的元素向后移
                for (k = i - 1; k > j; k--) {
                    arr[k + 1] = arr[k];
                }
                arr[k + 1] = temp;
            }
            for (int n = 0; n < arr.length; n++)
            {
                System.out.print(arr[n] + " ");
            }
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        int[] arr = { 10, 3, 9, 2, 3, 7, 90, 4 };
        int[] arr1 = insertion(arr);
        for (int i = 0; i < arr1.length; i++) {
            System.out.print(arr1[i] + " ");
        }
    }
}

结果为：
3 10 9 2 3 7 90 4
3 9 10 2 3 7 90 4
2 3 9 10 3 7 90 4
2 3 3 9 10 7 90 4
2 3 3 7 9 10 90 4
2 3 3 7 9 10 90 4
2 3 3 4 7 9 10 90
2 3 3 4 7 9 10 90

方法三：

package Insertion;
public class insertion3 {
    public static int[] insertion(int []arr)
    {
        int i,j;
        for(i=1;i<arr.length;i++)
        {
            if(arr[i]<arr[i-1])
            {
                int temp=arr[i];
                for(j=i-1;j>=0&&arr[j]>temp;j--)
                {
                    arr[j+1]=arr[j];
                }
                arr[j+1]=temp;
            }
            for(int n=0;n<arr.length;n++)
            {
                System.out.print(arr[n]+" ");
            } 
            System.out.println();
        }
        return arr;
    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int arr[]={1,5,2,4,7,3,8,6};
        int arr1[]=insertion(arr);
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }
    }
}

结果为：
1 5 2 4 7 3 8 6
1 2 5 4 7 3 8 6
1 2 4 5 7 3 8 6
1 2 4 5 7 3 8 6
1 2 3 4 5 7 8 6
1 2 3 4 5 7 8 6
1 2 3 4 5 6 7 8
1 2 3 4 5 6 7 8
方法四：
插入排序的递归实现

package Insertion;
public class insertion4 {
    public static int[] insertion(int []arr,int n)
    {
        if(n>0)
        {
            insertion(arr,n-1);
            sort(arr, n);
        }
            return arr;
    }
    //把数组arr的第n个插入到前n-1个数中,前n-1个数是已经排序好的。
    public static int[] sort(int [] arr,int n)
    {
        int i=n-1;
        int temp=arr[n];
        while(i>=0&&temp<arr[i])
        {
            arr[i+1]=arr[i];
            i--;
        }
        arr[i+1]=temp;
        for(int j=0;j<arr.length;j++)
        {
            System.out.print(arr[j]+" ");
        }
        System.out.println();
        return arr;
    }
    public static void main(String[] args) {
        int arr[]={10,6,2,9,13,5,4,11,2};
        int arr1[]=insertion(arr, arr.length-1);
        for(int i=0;i<arr1.length;i++)
        {
            System.out.print(arr1[i]+" ");
        }
    }
}

结果为：
6 10 2 9 13 5 4 11 2
2 6 10 9 13 5 4 11 2
2 6 9 10 13 5 4 11 2
2 6 9 10 13 5 4 11 2
2 5 6 9 10 13 4 11 2
2 4 5 6 9 10 13 11 2
2 4 5 6 9 10 11 13 2
2 2 4 5 6 9 10 11 13
2 2 4 5 6 9 10 11 13
空间复杂度：O(1)
时间复杂度：O(n*n)
最差情况：反序，需要移动n*(n-1)/2个元素 ，时间复杂度O(n*n)
最好情况：正序，不需要移动元素，时间复杂度为O(n)。
数组在已排序或者是“近似排序”时，插入排序效率的最好情况运行时间为O(n)。
插入排序最坏情况运行时间和平均情况运行时间都为O(n*n)。
通常，插入排序呈现出二次排序算法中的最佳性能。
对于具有较少元素（如n<=15）的列表来说，二次算法十分有效。
在列表已被排序时，插入排序是线性算法O(n)。
在列表“近似排序”时，插入排序仍然是线性算法。
在列表的许多元素已位于正确的位置上时，就会出现“近似排序”的条件。
通过使用O(nlog2n)效率的算法（如快速排序）对数组进行部分排序。
然后再进行选择排序，某些高级的排序算法就是这样实现的。