插入排序

  3 void insertSort (int *a, int length)
  4 {
  5     int i, j, temp;
  6 
  7     for (j = 1; j != length; j++)
  8     {
  9         temp = *(a + j);
 10         i = j - 1;
 11 
 12         while (i >= 0 && *(a + i) > temp)
 13         {
 14             *(a + i + 1) = *(a + i);
 15             i--;
 16         }
 17 
 18         *(a + i + 1) = temp;
 19     }
 20 }

第一层循环用于确定排序次数，即length - 1次

第二个循环用于移位,j 是用于确定要排的数，插到前面已经排序的里面

如同插扑克牌，写的时候先回忆一下过程

#include <stdio.h>

void insertSort (int *a, int length)
{
    int i, j, temp, k, mid;

    for (j = 1; j != length; j++)
    {
        temp = *(a + j);
        i = j;
        k = 0;
                
        while (k <= i)
        {
            mid = (i + k) / 2;
            if (*(a + mid) > temp)
            {
                i  = mid - 1;
            }
            else 
                k = mid + 1;
        }

        for (i = j - 1; i >= k; i--)
            *(a + i + 1) = *(a + i);

        *(a + k) = temp;
    }
}

在插入寻找插入点的时候通过二分查找，这对数组来说没有一点帮助，最后的for循环还是要进行，

但是如果时链表的话就不一样了

void insertSort (int* a, int n)
{
	if (n == 1)
		return;

	insertSort (a, n - 1);
	
	int i = n - 2;
	int temp = *(a + n - 1);
	while (i >= 0 && *(a + i) > temp)
	{
		*(a + i + 1) = *(a + i);
		i--;
	}

	*(a + i + 1) = temp;
}

分治的思想，每次都是把后一个插到前面 ，第10个插到前面已经排好序的9个数中 ==》将第9个插到前8个有序数中，递归到

n = 1的时候回归，那时有2个数，第二个插到第一个，第3个插前2个，以此类推

因为这样要递归n此，所以时间复杂度仍然为n2