数据结构6-排序算法（直接插入排序、希尔排序、快速排序、归并排序和堆排序）

        所有排序中，需要排序的数组array的第0位不存放有效的数字，而是作为哨兵存在。

1.直接插入排序

        直接插入排序的基本操作是将一个记录插入到已排好序的表中，从而得到一个新的、记录增1的有序表。一个无序的数字array（同时可以把它当做一个长度为1的有序表），从1以后的每个位置都希望找到自己合适的位置插入，第i位（i从2开始）数字要到自己位置插入，那么就需要从前i-1位开始依次比较（比前一位大，比后一位小），同时后移记录。直到有序表的长度为数组array的长度。

/// <summary>
/// 插入排序
/// </summary>
public void InsertSort(int[] array)
{
int i = 0, j = 0;

for (i = 2; i < array.Length; i++)
{
if (array[i] < array[i - 1])
{
array[0] = array[i];
array[i] = array[i - 1];
for (j = i - 2; array[0] < array[j]; j--)
{
array[j + 1] = array[j];
}
array[j + 1] = array[0];
}
}
}

        直接插入排序适合给本来就较为有序的数组做排序，因为数组越有序，插入的次数就越少。时间复杂度为O(n^2)。

2.希尔排序

        希尔排序是直接插入排序的一个改良版。它的思想是：先将整个待排记录序列分割成为若干子序列分别进行直接插入排序，待整个序列“基本有序”时，再对全体记录进行一次直接插入排序。

/// <summary>
/// 希尔排序
/// </summary>
/// <param name="array"></param>
public void ShellSort(int[] array)
{
int[] dlta = new[] {5, 3, 1};

for (int i = 0; i < dlta.Length; i++)
{
ShellInsert(array, dlta[i]);
}
}

private void ShellInsert(int[] array, int dk)
{
int i = 0, j = 0;

for (i = dk + 1; i < array.Length; i++)
{
if (array[i] < array[i - dk])
{
array[0] = array[i];
for (j = i - dk; j > 0 && array[0] < array[j]; j -= dk)
{
array[j + dk] = array[j];
}
array[j + dk] = array[0];
}
}
}

3.快速排序

        快速排序是冒泡排序的一种改进版。它的基本思想是，通过一趟排序将带排序记录分割成独立的两部分，其中一部分记录的关键字均比另一部分记录的关键字小，则可分别对这两部分记录继续进行排序，已达到整个序列有序。

/// <summary>
/// 快速排序
/// </summary>
/// <param name="array"></param>
public void QuickSort(int[] array)
{
QSort(array, 1, array.Length - 1);
}

private void QSort(int[] array, int low, int high)
{
if (low < high)
{
int pivokey = Partition(array, low, high);
QSort(array, low, pivokey - 1);
QSort(array, pivokey + 1, high);
}
}

private int Partition(int[] array, int low, int high)
{
array[0] = array[low];
int pivokey = array[low];
while (low < high)
{
while (low < high && array[high] >= pivokey) high--;
array[low] = array[high];
while (low < high && array[low] <= pivokey) low++;
array[high] = array[low];
}
array[low] = pivokey;
return low;
}

        快速排序适合比较“乱”的序列，若序列已经有序，则快速排序会非常的慢。时间复杂度O（nlogn）。

4.归并排序

        归并排序的思想是，把初始的序列表的每一个关键字都视为一个序列表，然后将相邻两序列表合并成一个序列表并排序，多次合并后最终达到只剩一个表。

/// <summary>
/// 归并排序
/// </summary>
/// <param name="array"></param>
public void MergeSort(int[] array)
{
//归并排序
for (int i = 1; i < array.Length; i *= 2)
{
MergePass(array, i);
}
}

private void Merge(int[] array, int low, int mid, int high)
{
int i = low;
int j = mid + 1;
int k = 0;
int[] array2 = new int[high - low + 1];

while (i <= mid && j <= high)
{
if (array[i] <= array[j])
{
array2[k] = array[i];
i++;
k++;
}
else
{
array2[k] = array[j];
j++;
k++;
}
}

while (i <= mid)
{
array2[k] = array[i];
k++;
i++;
}

while (j <= high)
{
array2[k] = array[j];
k++;
j++;
}

for (k = 0, i = low; i < high; k++, i++)
{
array[i] = array2[k];
}
}

private void MergePass(int[] array, int gap)
{
int i =0;
for (i = 0; i + 2*gap - 1 < array.Length; i += 2*gap)
{
Merge(array, i, i + gap - 1, i + 2*gap - 1);
}
if (i + gap - 1 < array.Length)
{
Merge(array, i, i + gap - 1, array.Length - 1);
}
}

        归并排序是一种非常稳定的排序，在多数情况下排序时间都可以稳定到一个小的范围内。时间复杂度O(nlogn)。

5.堆排序

        当序列满足Ki >= K(2i) && Ki >= K(2i+1)时，这个序列就是大顶堆，简单的说就是制造出一个二叉树，其根节点大于两子节点。堆排序就需要制造出这些大顶堆，则堆顶的就是最大的数，我们把堆顶移到序列末尾，再重新制造大顶堆，重复之前的步骤。

/// <summary>
/// 堆排序
/// </summary>
/// <param name="array"></param>
public void HeapSort(int[] array)
{
for (int i = array.Length/2; i >= 1; i--)                //非叶子节点的最大角标为Lenth/2
{
HeapAdjust(array, i, array.Length - 1);
}
for (int i = array.Length - 1; i > 1; i--)
{
int temp = array[1];
array[1] = array[i];
array[i] = temp;

HeapAdjust(array, 1, i - 1);
}
}

private void HeapAdjust(int[] array, int s, int m)
{
int tmp = array[s];
for (int j = 2*s; j <= m; j *= 2)
{
if (j < m && array[j] < array[j + 1]) j++;
if (tmp < array[j])
{
array[s] = array[j];
s = j;
}

else
break;
}
array[s] = tmp;
}

        堆排序不适合对记录较少的文件做排序，但很适合对较大的文件排序。时间复杂度O（nlogn）