直接插入排序

直接插入排序是一种最简单的排序方法，它的基本操作是将一个记录插入到已排好的有序的表中，从而得到一个新的、记录数增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)效率的算法（如快速排序）对数组进行部分排序。
然后再进行选择排序，某些高级的排序算法就是这样实现的。