排序算法

概述

插入排序

直接插入排序

基本思想

将一个记录插入到一个已排序好的有序表中得到一个新的有序表，即先将第一个记录看成一个有序的子序列，从第二个记录开始逐个插入到前面的有序列中。

代码实现

static void InsertSort(int[] array)
{
    for(int i=1;i<array.Length;i++)
    {
        int temp=array[i];
        int j=i-1;
        while(j>=0&&temp<array[j])
        {
            array[j+1]=array[j];
            j--;
        }
        array[j+1]=temp;
    }
}

希尔排序

定义

希尔排序是“插入排序”的一种，又叫“缩小增量排序”。

基本思想

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组，把距离为d1的数据放进一个组中，一共可以分为d1个组，对这d1个组分别进行直接插入排序，然后取第二个增量d2 < <script id="MathJax-Element-1" type="math/tex"><</script>d1重复上面的分组和排序，直至$d_t$=1($d_t<d_{t-1}...<d_2<d_1$)，我们来通过演示图，更深入的理解这个过程

代码实现

        static void ShellSort(int[] array)
        {
            int gap = array.Length / 2;
            while (gap >= 1)
            {
                for (int i = gap; i < array.Length; i++)
                {
                    int temp = array[i];
                    int j = 0;
                    for (j = i - gap; j >= 0 && temp < array[j]; j = j - gap)
                    {
                        array[j + gap] = array[j];
                    }
                    array[j+gap] = temp;
                }
                gap = gap / 2;
            }
        }

选择排序

直接选择排序

代码实现

static void SelectSort(int[]array)
{
    for(int i=0;i<array.Length;i++)
    {
        int index=i;
        int temp=array[i]；
        for(int j=i+1;j<array.Length;j++)
        {
            if(array[index]>array[j])
            {
                index=j;
            }
        }
        temp=array[i];
        array[i]=array[index];
        array[index]=temp;
    }
}

堆排序

基本思想

构造了初始堆后，我们来看一下完整的堆排序处理：

下面是控制台演示

代码实现

“`c#
static void heapSort(int[] list)
{
// 循环建立初始堆
for (int i = list.Length / 2; i >= 0; i–)
{
HeapAdjust(list, i, list.Length - 1);
}
// 进行n-1次循环，完成排序
for (int i = list.Length - 1; i > 0; i–)
{
// 最后一个元素和第一元素进行交换
int temp = list[i];
list[i] = list[0];
list[0] = temp;
// 筛选 R[0] 结点，得到i-1个结点的堆
HeapAdjust(list, 0, i);
}
}
static void HeapAdjust(int[] array, int parent, int length)
{
int temp = array[parent]; // temp保存当前父节点
int child = 2 * parent + 1; // 先获得左孩子

        while (child < length)
        {
            // 如果有右孩子结点，并且右孩子结点的值大于左孩子结点，则选取右孩子结点
            if (child + 1 < length && array[child] < array[child + 1])
            {
                child++;
            }
            // 如果父结点的值已经大于孩子结点的值，则直接结束
            if (temp >= array[child])
                break;
            // 把孩子结点的值赋给父结点
            array[parent] = array[child];
            // 选取孩子结点的左孩子结点,继续向下筛选
            parent = child;
            child = 2 * child + 1;
        }
        array[parent] = temp;
    }
    ```

交换排序

冒泡排序

快速排序

参考：http://www.cnblogs.com/jingmoxukong/p/4303826.html