排序的算法有非常多。在维基百科上有这么一个分类，另外大家有兴趣也能够直接上维基百科上看相关算法。本文也參考了上面的内容。

首先来看比較简单的选择排序(Selection sort)，插入排序(Insertion sort)，然后在分析插入排序的特征和缺点的基础上。介绍在插入排序基础上改进的希尔排序(Shell sort)。

一 选择排序

原理：

选择排序非常easy，他的过程例如以下：

1. 从左至右遍历，找到最小(大)的元素。然后与第一个元素交换。
2. 从剩余未排序元素中继续寻找最小（大）元素。然后与第二个元素进行交换。
3. 以此类推，直到全部元素均排序完成。

之所以称之为选择排序，是由于每一次遍历未排序的序列我们总是从中选择出最小的元素。以下是选择排序的动画演示：

实现：

算法实现起来也非常easy。我们新建一个Sort泛型类，让该类型必须实现IComparable接口，然后我们定义SelectionSort方法，方法传入T数组。代码例如以下：

/// <summary>
/// 排序算法泛型类，要求类型实现IComparable接口
/// </summary>
/// <typeparam name="T"></typeparam>
public class Sort<T> where T : IComparable<T>
{
    /// <summary>
    /// 选择排序
    /// </summary>
    /// <param name="array"></param>
    public static void SelectionSort(T[] array)
    {
        int n = array.Length;

        for (int i = 0; i < n; i++)
        {
            int min = i;
            //从第i+1个元素開始，找最小值
            for (int j = i + 1; j < n; j++)
            {
                if (array[min].CompareTo(array[j]) > 0)
                    min = j;
            }
            //找到之后和第i个元素交换
            Swap(array, i, min);
        }
    }

    /// <summary>
    /// 元素交换
    /// </summary>
    /// <param name="array"></param>
    /// <param name="i"></param>
    /// <param name="min"></param>
    private static void Swap(T[] array, int i, int min)
    {
        T temp = array[i];
        array[i] = array[min];
        array[min] = temp;
    }
}

下图分析了选择排序中每一次排序的过程，您能够对比图中右边的柱状图来看。

測试例如以下：

static void Main(string[] args)
{
    Int32[] array = new Int32[] { 1, 3, 1, 4, 2, 4, 2, 3, 2, 4, 7, 6, 6, 7, 5, 5, 7, 7 };
    Console.WriteLine("Before SelectionSort:");
    PrintArray(array);
    Sort<Int32>.SelectionSort(array);
    Console.WriteLine("After SelectionSort:");
    PrintArray(array);
    Console.ReadKey();
}

输出结果：

分析：

选择排序的在各种初始条件下的排序效果例如以下：

1. 选择排序须要花费 (N – 1) + (N – 2) + ... + 1 + 0 = N(N- 1) / 2 ~ N²/2次比較 和N-1次交换操作。

2. 对初始数据不敏感。无论初始的数据有没有排好序，都须要经历N²/2次比較，这对于一些原本排好序。或者近似排好序的序列来说并不具有优势。

   在最好的情况下，即全部的排好序，须要0次交换，最差的情况。倒序。须要N-1次交换。

3. 数据交换的次数较少。假设某个元素位于正确的终于位置上。则它不会被移动。在最差情况下也仅仅须要进行N-1次数据交换，在全部的全然依靠交换去移动元素的排序方法中。选择排序属于比較好的一种。

二 插入排序

原理：

插入排序也是一种比較直观的排序方式。能够以我们寻常打扑克牌为例来说明，如果我们那在手上的牌都是排好序的，那么插入排序能够理解为我们每一次将摸到的牌。和手中的牌从左到右依次进行对照，如果找到合适的位置则直接插入。

详细的步骤为：

1. 从第一个元素開始，该元素能够觉得已经被排序
2. 取出下一个元素。在已经排序的元素序列中从后向前扫描
3. 假设该元素小于前面的元素（已排序），则依次与前面元素进行比較假设小于则交换。直到找到大于该元素的就则停止；
4. 假设该元素大于前面的元素（已排序），则反复步骤2
5. 反复步骤2~4 直到全部元素都排好序 。

以下是插入排序的动画演示：

实现：

在Sort泛型方法中，我们加入例如以下方法，以下的方法和上面的定义一样

/// <summary>
/// 插入排序
/// </summary>
/// <param name="array"></param>
public static void InsertionSort(T[] array)
{
    int n = array.Length;
    //从第二个元素開始
    for (int i = 1; i < n; i++)
    {
        //从第i个元素開始，一次和前面已经排好序的i-1个元素比較，假设小于。则交换
        for (int j = i; j > 0; j--)
        {
            if (array[j].CompareTo(array[j - 1]) < 0)
            {
                Swap(array, j, j - 1);
            }
            else//假设大于。则不用继续往前比較了，由于前面的元素已经排好序，比較大的大就是教大的了。
                break;
        }
    }
}

測试例如以下：

Int32[] array1 = new Int32[] { 1, 3, 1, 4, 2, 4, 2, 3, 2, 4, 7, 6, 6, 7, 5, 5, 7, 7 };
Console.WriteLine("Before InsertionSort:");
PrintArray(array1);
Sort<Int32>.InsertionSort(array1);
Console.WriteLine("After InsertionSort:");
PrintArray(array1);
Console.ReadKey();

输出结果：

分析：

插入排序的在各种初始条件下的排序效果例如以下：

1. 插入排序平均须要N²/4次比較和N²/4 次交换。在最坏的情况下须要N²/2 次比較和交换；在最好的情况下仅仅须要N-1次比較和0次交换。

先考虑最坏情况，那就是全部的元素逆序排列，那么第i个元素须要与前面的i-1个元素进行i-1次比較和交换。全部的加起来大概等于N(N- 1) / 2 ~ N² / 2。在数组随机排列的情况下，仅仅须要和前面一半的元素进行比較和交换，所以平均须要N²/4次比較和N²/4 次交换。

在最好的情况下，全部元素都排好序，仅仅须要从第二个元素開始都和前面的元素比較一次就可以，不须要交换。所以为N-1次比較和0次交换。

2. 插入排序中，元素交换的次数等于序列中逆序元素的对数。元素比較的次数最少为元素逆序元素的对数，最多为元素逆序的对数 加上数组的个数减1。

3.整体来说。插入排序对于部分有序序列以及元素个数比較小的序列是一种比較有效的方式。

如上图中，序列AEELMOTRXPS。中逆序的对数为T-R，T-P。T-S，R-P。X-S 6对。典型的部分有序队列的特征有：

• 数组中每一个元素离终于排好序后的位置不太远
• 小的未排序的数组加入到大的已排好序的数组后面
• 数组中仅仅有个别元素未排好序

对于部分有序数组，插入排序是比較有效的。当数组中逆元素的对数越低，插入排序要比其它排序方法要高效的多。

选择排序和插入排序的比較：

上图展示了插入排序和选择排序的动画效果。图中灰色的柱子是不用动的，黑色的是须要參与到比較中的，红色的是參与交换的。

图中能够看出：

插入排序不会动右边的元素。选择排序不会动左边的元素；因为插入排序涉及到的未触及的元素要比插入的元素要少，涉及到的比較操作平均要比选择排序少一半。

三 希尔排序(Shell Sort)

原理：

希尔排序也称之为递减增量排序。他是对插入排序的改进。在第二部插入排序中。我们知道。插入排序对于近似已排好序的序列来说。效率非常高，能够达到线性排序的效率。可是插入排序效率也是比較低的，他一次仅仅能将数据向前移一位。比方假设一个长度为N的序列，最小的元素假设恰巧在末尾，那么使用插入排序仍需一步一步的向前移动和比較，要N-1次比較和交换。

希尔排序通过将待比較的元素划分为几个区域来提升插入排序的效率。这样能够让元素能够一次性的朝终于位置迈进一大步，然后算法再取越来越小的步长进行排序。最后一步就是步长为1的普通的插入排序的，可是这个时候，整个序列已经是近似排好序的，所以效率高。

例如以下图，我们对以下数组进行排序的时候，首先以4为步长，这是元素分为了LMPT，EHSS。ELOX，AELR几个序列，我们对这几个独立的序列进行插入排序。排序完毕之后。我们减小步长继续排序。最后直到步长为1，步长为1即为一般的插入排序，他保证了元素一定会被排序。

希尔排序的增量递减算法能够任意指定，能够以N/2递减，仅仅要保证最后的步长为1就可以。

实现：

/// <summary>
/// 希尔排序
/// </summary>
/// <param name="array"></param>
public static void ShellSort(T[] array)
{
    int n = array.Length;
    int h = 1;
    //初始最大步长
    while (h < n / 3) h = h * 3 + 1;
    while (h >= 1)
    {
        //从第二个元素開始
        for (int i = 1; i < n; i++)
        {
            //从第i个元素開始，依次次和前面已经排好序的i-h个元素比較，假设小于，则交换
            for (int j = i; j >= h; j = j - h)
            {
                if (array[j].CompareTo(array[j - h]) < 0)
                {
                    Swap(array, j, j - h);
                }
                else//假设大于。则不用继续往前比較了，由于前面的元素已经排好序，比較大的大就是教大的了。

                    break;
            }
        }
        //步长除3递减
        h = h / 3;
    }
}

能够看到，希尔排序的实现是在插入排序的基础上改进的，插入排序的步长为1，每一次递减1。希尔排序的步长为我们定义的h。然后每一次和前面的-h位置上的元素进行比較。

算法中，我们首先获取小于N/3 的最大的步长，然后逐步长递减至步长为1的一般的插入排序。

以下是希尔排序在各种情况下的排序动画：

分析：

1. 希尔排序的关键在于步长递减序列的确定，不论什么递减至1步长的序列都能够，眼下已知的比較好的序列有：

• Shell‘s 序列: N/2 , N/4 , ..., 1 (反复除以2);
• Hibbard‘s 序列: 1, 3, 7, ..., 2^k - 1 ;
• Knuth‘s 序列: 1, 4, 13, ..., (3^k - 1) / 2 ;该序列是本文代码中使用的序列。

• 已知最好的序列是 Sedgewick‘s (Knuth的学生，Algorithems的作者)的序列: 1, 5, 19, 41, 109, ....

          该序列由以下两个表达式交互获得:

• 1, 19, 109, 505, 2161,….., 9(4^k – 2^k) + 1, k = 0, 1, 2, 3,…
• 5, 41, 209, 929, 3905,…..2^k+2 (2^k+2 – 3 ) + 1, k = 0, 1, 2, 3, …

“比較在希尔排序中是最基本的操作。而不是交换。

”用这样步长的希尔排序比插入排序和堆排序都要快，甚至在小数组中比高速排序还快，可是在涉及大量数据时希尔排序还是比高速排序慢。

2. 希尔排序的分析比較复杂。使用Hibbard’s 递减步长序列的时间复杂度为O(N^3/2)，平均时间复杂度大约为O(N^5/4) ,详细的复杂度眼下仍存在争议。

3. 实验表明，对于中型的序列( 万)。希尔排序的时间复杂度接近最快的排序算法的时间复杂度nlogn。

四 总结

最后总结一下本文介绍的三种排序算法的最好最坏和平均时间复杂度。

     希望本文对您了解以上三个主要的排序算法有所帮助，后面将会介绍合并排序和高速排序。