直接插入排序的基本思想：每趟將一個待排元素作為關鍵字，按照其關鍵字值得大小插入到已經排好序的部分序列的適當位置，直到插入完成。

演算法思想總結如下：（設待排序的陣列為a[0…n-1]）

1、初始時，a[0]就是第一個有序區間，無序區間為a[1…n-1]；
2、將a[i]併入當前的有序區a[0…i-1]中形成a[0…i]的有序區間；
3、i++並重復第二步，知道i=n-1，此時排序完成。

直接插入排序基本演算法實現如下：

void insertSort1(int[] a,int n){
        int i,j,temp;
        //第一個元素有序，所以從第二個開始處理
 

        for (i = 1; i < n; i++) {
              temp = a[i];//將待排元素暫存於temp中
              j = i - 1;
              //從待排元素之前的元素開始掃描，如果大於待排元素，則後移一位
              while(j >= 0 && a[j] > temp){
                    a[j + 1] = a[j];
                    j--;
              }
              //找到插入位置，將temp中暫存的待排元素插入
 

              a[j + 1] = temp;
        }
  }

java程式碼實現如下：

public class InsertSort {
      public static void main(String[] args) {
            int[] a = {5,2,9,6,8,4,3,0};
            insertSort1(a,8);
            for (int i = 0; i < a.length; i++) {
                  System.out.println(a[i]);
            }
            System.out
 
.println("**************");
            int[] b = {5,2,9,6,8,4,3,0};
            insertSort2(b,8);
            for (int i = 0; i < b.length; i++) {
                  System.out.println(b[i]);
            }
      }

      public static void insertSort1(int[] a,int n){
            int i,j,temp;
            //第一個元素有序，所以從第二個開始處理
            for (i = 1; i < n; i++) {
                  temp = a[i];//將待排元素暫存於temp中
                  j = i - 1;
                  //從待排元素之前的元素開始掃描，如果大於待排元素，則後移一位
                  while(j >= 0 && a[j] > temp){
                        a[j + 1] = a[j];
                        j--;
                  }
                  //找到插入位置，將temp中暫存的待排元素插入
                  a[j + 1] = temp;
            }
      }

    public static void insertSort2(int[] a, int n){
          int i,j;
          for (i = 1; i < n; i++) {
                if (a[i] < a[i-1]) {
                      int temp = a[i];
                      for (j = i-1; j >= 0 && a[j] > temp; j--) {
                           a[j+1] = a[j];
                     }
                     a[j+1] = temp;
               }
         }
   }
}

時間複雜度：

考慮最壞的情況，即整個序列式逆序的，則內層迴圈temp < a[j]這個條件是始終成立的。此時，對於每一次外層迴圈，最內層迴圈的執行次數（也就是基本操作a[j+1] = a[j] 的執行次數）達到最大值，為i次，i的取值範圍為2~n，由此可得基本操作總的執行次數為n(n-1)/2，時間複雜度為O(n2){n的平方}。

考慮最好的情況，即整個序列已經是有序序列，則對於內層迴圈temp < a[j]這個條件是始終不成立的。此時內層迴圈始終不執行，時間複雜度為**重點內容**0(n)。

空間複雜度：

由演算法程式碼可知，演算法所需的額外空間只有一個temp，因此它的空間複雜度為0(1)。