直接插入排序的演算法思路是：
基於給定的一個數組，初始時假設第一個記錄自成一個有序序列，其餘記錄為無序序列。接著從第二個記錄開始，按照記錄的大小依次將當前處理的記錄插入到其之前的有序序列中，直至最後一個記錄插入到有序序列中為止。

package demo;

public class InsertSort {
        public static void main(String[] args) {
//          int[] m=processArray();
            //為了方便測試，還是使用固定陣列
            int[] m={11,9
 
,77,66,23,83,31,2,71,10};
            long startTimeMs = System.currentTimeMillis();
            insertSort(m);
            long endTimeMs = System.currentTimeMillis();
            System.out.println("排序時間為"+(endTimeMs-startTimeMs)+"ms");
        }

        public static void insertSort(int[] a) {
            int
 
 tmp;
            System.out.println("排序之前：           "+toString(a));
            for (int i = 1; i < a.length; i++) {//迴圈1
                    for (int j = i; j > 0; j--) { //迴圈2
                        if (a[j] < a[j - 1]) {
                            tmp = a[j - 1];
                            a[j - 1
 
] = a[j];
                            a[j] = tmp;
                        }
                    }
               System.out.println("第"+i+"趟排序結果："+toString(a));
            }
        }
//      public static void insertSort(int[] arr){     
//          System.out.println("排序之前：           "+toString(arr));
//          for(int i = 1;i < arr.length; i ++){
//              if(arr[i] < arr[i-1]){//注意[0,i-1]都是有序的。如果待插入元素比arr[i-1]還大則無需再與[i-1]前面的元素進行比較了，反之則進入if語句
//                  int temp = arr[i];
//                  int j;
//                  for(j = i-1; j >= 0 && arr[j] > temp; j --){                
//                          arr[j+1] = arr[j];//把比temp大的元素全部往後移動一個位置            
//                  }
//                  arr[j+1] = temp;//把待排序的元素temp插入騰出位置的(j+1)
//              }   
//              System.out.println("第"+i+"趟排序結果："+toString(arr));
//          }
//          
//      }

        //將陣列轉為字串
        public static String toString(int[] a){
            StringBuffer sb=new StringBuffer();
               for(int each:a){
                   sb.append(each+" ");
               }
               return  sb.toString();
        }
        //產生一個隨機陣列，存放10個不重複的100以內的數字
        private static int[] processArray() {
            int[] m=new int[10];
            for(int j=0;j<10;j++){
                int i=(int) Math.ceil(Math.random()*100);
                m[j]=i;
                for(int k=0;k<j;k++){
                       if(m[j] == m[k]){
                          j--;
                          break;
                       }
                    }
            }
            return m;
        }
}

註釋的insertSort()是另一種交換方案，但是每次都會進入迴圈2，不是很好。
時間複雜度分析：
最好情況下：
若陣列為正序，只進行了迴圈1，比較了n-1次，沒有移動，時間複雜度為O（n）；
最壞情況下：
若陣列為反序：
比較次數為1+2+3+….+(n-1）=O(n^2);
移動次數為（1+2）+（2+2）+…+（n-1+2）=(n-1)*(n-4)/2=O(n^2) i取值範圍1~n-1,時間複雜度為O(n^2);
空間複雜度分析：
在直接插入排序中只使用了i,j,temp這3個輔助元素，與問題規模無關，所以空間複雜度為O(1)。
穩定性分析：
在整個排序結束後，相同元素的相對位置沒有發生變化，所以直接插入排序是一種穩定排序。