直接插入排序

插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5. 将新元素插入到该位置后
6. 重复步骤2~5

   // 参考白话经典算法之直接插入排序的思想
   #include <stdio.h>
   
   void SwapValue(int *OperatorA, int *OperatorB)
   {
       if ((NULL == OperatorA) || (NULL == OperatorB))
       {
           printf ("Invalid Parameter(s)!\n");
           return;
       }
   
       if ((*OperatorA) != (*OperatorB))
       {
           *OperatorA ^= *OperatorB;
           *OperatorB ^= *OperatorA;
           *OperatorA ^= *OperatorB;
       }
   }
   
   void InsertSort(int *a, int N)
   {
       if ((NULL == a) || (N <= 0))
       {
           printf ("Invalid Parameter(s)!\n");
           return;
       }
   
       for (int i = 1; i < N; ++i)
       {
           int j;
   
           for (j = i-1; j >= 0; --j)
           {
               if (a[j] <= a[i])
               {
                   break;
               }
           }
   
           int nTemp = a[i];
   
           for (int k = i - 1; k > j; --k)
           {
               a[k+1] = a[k];
           }
   
           a[j+1] = nTemp;
       }
   }
   
   // 优化一，若在a[i]本就与a[0...i-1]有序则直接跳入下论循环
   void InsertSort1(int *a, int N)
   {
       if ((NULL == a) || (N <= 0))
       {
           printf ("Invalid Parameter(s)!\n");
           return;
       }
   
       for (int i = 1; i < N; ++i)
       {
           if (a[i] < a[i-1])
           {
               int j;
   
               for (j = i-1; j >= 0; --j)
               {
                   if (a[j] <= a[i])
                   {
                       break;
                   }
               }
   
               int nTemp = a[i];
   
               for (int k = i - 1; k > j; --k)
               {
                   a[k+1] = a[k];
               }
   
               a[j+1] = nTemp;
           }
       }
   }
   
   // 优化二，将搜索和移位和并在一起实现
   void InsertSort2(int *a, int N)
   {
       if ((NULL == a) || (N <= 0))
       {
           printf ("Invalid Parameter(s)!\n");
           return;
       }
   
       for (int i = 1; i < N; ++i)
       {
           if (a[i] < a[i-1])
           {
               int nTemp = a[i];
   
               for (int j = i - 1; (j >= 0) && (a[j] > nTemp); --j)
               {
                   SwapValue (&a[j+1], &a[j]);
               }
           }
       }
   }
   
   int main(void)
   {
       int a1[9] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
       int a2[9] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
       int a3[9] = {9, 8, 7, 6, 5, 4, 3, 2, 1};
   
       InsertSort (a1, 9);
       InsertSort1 (a2, 9);
       InsertSort2 (a3, 9);
   
       for (int i = 0; i < 9; ++i)
       {
           printf ("%d ", a1[i]);
       }
   
       printf ("\n");
   
       for (int i = 0; i < 9; ++i)
       {
           printf ("%d ", a2[i]);
       }
   
       printf ("\n");
   
       for (int i = 0; i < 9; ++i)
       {
           printf ("%d ", a3[i]);
       }
   
       printf ("\n");
   
       return 0;
   }