8种排序算法的C#实现

发表于 | 分类于

排序是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列。排序根据涉及的存储器的不同分为内部排序和外部排序。

内部排序是指待排序记录存放在内存进行的排序过程；外部排序是指待排序记录的数量很大，以致内存一次不能容纳全部记录，在排序过程中尚需对外存进行访问的排序过程。本文仅讨论内部排序。

1 直接插入排序

最简单的排序方法，基本操作是将一个记录插入到已排好序的有序表中，从而得到一个新的、记录数增1的有序表。

此处为了程序的通用，没有采取数组0位作为哨兵位的做法。

直接插入排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
public static int[] StraightInsertionSort(int[] arr)
{
    int temp;
    for (int i = 1; i < arr.Length; i++)
    {
        if (arr[i] < arr[i - 1])
        {
            //将arr[i]元素存入temp
            temp = arr[i];
            int j = i;

            //将i左侧比i大的元素右移一位
            do
            {
                arr[j] = arr[j - 1];
                j--;
            } while (j > 0 && temp < arr[j - 1]);

            //将temp存入比i大的最小元素的左侧位置
            arr[j] = temp;
        }

        /*上边实现方法的简化写法，但需要多判断一次，因为初始时j==i==1>0
        int j = i;
        while (j > 0 && arr[j] < arr[j - 1])
        {
            temp = arr[j];
            arr[j] = arr[j - 1];
            arr[j - 1] = temp;
            j--;
        }
        */
    }
    return arr;
}

2 希尔排序

又称“缩小增量排序”，也是一种属插入排序类的方法，但在时间效率上较直接插入排序有较大的改进。

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

希尔排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
public static int[] ShellSort(int[] arr)
{
    int temp;
    //初始步长
    int gap = arr.Length / 2;
    while (gap != 0)
    {
        #region 改进版的直接插入排序
        for (int i = gap; i < arr.Length; i++)
        {
            if (arr[i] < arr[i - gap])
            {
                temp = arr[i];
                int j = i;

                do
                {
                    arr[j] = arr[j - gap];
                    j -= gap;
                } while (j - gap >= 0 && temp < arr[j - gap]);

                arr[j] = temp;
            }
        }
        #endregion
                
        //缩小增量
        gap /= 2; 
    }
    return arr;
}

3 冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

冒泡排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static int[] BubbleSort(int[] arr)
{
    int temp;
    //每趟排序将无序元素中的最小元素换到有序元素的右侧
    for (int i = 0; i < arr.Length - 1; i++)
    {
        for (int j = arr.Length - 1; j > i; j--)
        {
            if (arr[j - 1] > arr[j])
            {
                temp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

4 快速排序

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

快速排序是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短。

快速排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
public static int[] QuickSort(int[] arr)
{
    return QuickSort(arr, 0, arr.Length - 1);
}

/// <summary>
/// 递归快速排序
/// </summary>
/// <param name="arr">目标数组</param>
/// <param name="low">数组起始位置</param>
/// <param name="high">数组终止位置</param>
/// <returns></returns>
private static int[] QuickSort(int[] arr, int low, int high)
{
    if (low < high)
    {
        //将目标数组一分为二，得到枢轴位置
        int pivotLoc = Partition(arr, low, high);
        //对低子表递归排序
        QuickSort(arr, low, pivotLoc - 1);
        //对高子表递归排序
        QuickSort(arr, pivotLoc + 1, high);
    }
    return arr;
}
        
private static void Swap(ref int index, ref int indexReplace)
{
    int temp = index;
    index = indexReplace;
    indexReplace = temp;
}

/// <summary>
/// 一趟快排
/// </summary>
/// <param name="arr">目标数组</param>
/// <param name="low">数组起始位置</param>
/// <param name="high">数组终止位置</param>
/// <returns></returns>
private static int Partition(int[] arr, int low, int high)
{
    //用子表的第一个记录作枢轴记录
    int pivotKey = arr[low];
    //从表的两端交替地向中间扫描
    while (low < high)
    {
        //将比枢轴记录小的记录交换到低端
        while (low < high && arr[high] >= pivotKey)
        {
            --high;
        }
        arr[low] = arr[high];
        //将比枢轴记录大的记录交换到高端
        while (low < high && arr[low] <= pivotKey)
        {
            ++low;
        }
        arr[high] = arr[low];
    }
    //枢轴记录到位
    arr[low] = pivotKey;
    return low;
}

5 简单选择排序

一趟简单排序的操作为：通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i（1<=i<=n）个记录交换。

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public static int[] SimpleSelectionSort(int[] arr)
{
    int temp;
    //每趟排序将无序元素中的最小元素换到有序元素的右侧
    for (int i = 0; i < arr.Length; i++)
    {
        int min = i;
        for (int j = i + 1; j < arr.Length; j++)
        {
            if (arr[j] < arr[min])
            {
                min = j;
            }
        }
        temp = arr[i];
        arr[i] = arr[min];
        arr[min] = temp;
    }
    return arr;
}

6 堆排序

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n 个元素中最小（或最大）的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n 个元素中次小（或次大）的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。

堆排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
private static int heapSize;
public static int[] HeapSort(int[] arr)
{
    heapSize = arr.Length;
    //构建最大堆
    for (int i = arr.Length / 2; i > 0; i--)
    {
        BuildMaxHeap(arr, i);
    }
    //将堆顶元素放入堆底的有序序列，并重新调整最大堆
    for (int i = arr.Length - 1; i > 0; i--)
    {
        //每次在构建好最大堆后，将第一个元素arr[0]和最后一个元素arr[i]交换
        swapHeap(arr, 0, i);
        //此时arr[i]为堆的最大值，所以对arr[0]到arr[i - 1]元素进行调整
        heapSize--;
        //每次新组成的堆除了根节点其他的节点都保持最大堆的特性，因此只要再以根节点为基准调整就可以得到新的最大堆
        BuildMaxHeap(arr, 1);
    }
    return arr;
}

//构建最大堆：调整当前节点和子节点使当前节点为最大元素
private static void BuildMaxHeap(int[] arr, int index)
{
    int largeIndex = index;
    //当前节点的左子节点
    int leftChildIndex = index << 1;
    //当前节点的右子节点
    int rightChildIndex = (index << 1) + 1;
    //左子节点存在且左子节点大于当前节点
    if (leftChildIndex <= heapSize && arr[leftChildIndex - 1] > arr[largeIndex - 1])
    {
        largeIndex = leftChildIndex;
    }
    //右子节点存在且右子节点大于当前节点
    if (rightChildIndex <= heapSize && arr[rightChildIndex - 1] > arr[largeIndex - 1])
    {
        largeIndex = rightChildIndex;
    }
    if (index != largeIndex)
    {
        swapHeap(arr, index - 1, largeIndex - 1);
        BuildMaxHeap(arr, largeIndex);
    }
}

//互换堆中的两个值
private static void swapHeap(int[] arr, int index, int indexReplace)
{
    int temp = arr[index];
    arr[index] = arr[indexReplace];
    arr[indexReplace] = temp;
}

7 归并排序

归并排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
public static int[] MergeSort(int[] arr)
{
    //在整个排序过程中始终使用同一个暂存数组，空间利用率高
    int[] tempArr = new int[arr.Length];
    return MergeSort(arr, tempArr, 0, arr.Length - 1);
}

/// <summary>
/// 将目标数组循环折半，递归执行归并排序核心，再组合成有序数组
/// </summary>
/// <param name="arr">目标数组</param>
/// <param name="tempArr">暂存数组</param>
/// <param name="first">子表的起始位置</param>
/// <param name="last">子表的终止位置</param>
/// <returns></returns>
private static int[] MergeSort(int[] arr, int[] tempArr, int first, int last)
{
    if (first < last)
    {
        int mid = (first + last) / 2;
        MergeSort(arr, tempArr, first, mid);
        MergeSort(arr, tempArr, mid + 1, last);
        MergeSortCore(arr, tempArr, first, mid, last);
    }
    return arr;
}

/// <summary>
/// 归并排序核心:将两个有序的左右子表（以mid区分），合并成一个有序表
/// </summary>
/// <param name="arr">目标数组</param>
/// <param name="tempArr">暂存数组</param>
/// <param name="first">子表的起始位置</param>
/// <param name="mid">子表的划分位置</param>
/// <param name="last">子表的终止位置</param>
/// <returns></returns>
private static int[] MergeSortCore(int[] arr, int[] tempArr, int first, int mid, int last)
{
    //左侧子表的起始位置
    int indexA = first;
    //右侧子表的起始位置
    int indexB = mid + 1;
    int tempIndex = 0;
    //遍历左右子表，直到其中一个表遍历完
    while (indexA <= mid && indexB <= last)
    {
        //左子表的最小元素 <= 右子表的最小元素
        if (arr[indexA] <= arr[indexB])
        {
            //左子表的最小元素暂存数组，遍历左子表下标+1
            tempArr[tempIndex++] = arr[indexA++];
        }
        else
        {
            tempArr[tempIndex++] = arr[indexB++];
        }
    }
    //有一侧子表遍历完后，将另一侧子表剩下的数一次放入暂存数组中，暂存数组保持有序
    while (indexA <= mid)
    {
        tempArr[tempIndex++] = arr[indexA++];
    }
    while (indexB <= last)
    {
        tempArr[tempIndex++] = arr[indexB++];
    }
    //将暂存数组中有序的元素写回到目标数组的指定位置，使进行归并的数组段有序
    tempIndex = 0;
    for (int i = first; i <= last; i++)
    {
        arr[i] = tempArr[tempIndex++];
    }
    return arr;
}

8 基数排序

基数排序是借助“分配”和“收集”两种操作对单逻辑关键字进行排序的一种内部排序方法。例如，若关键字是数值，且其值都在0<=k<=999范围内，则可把每一个十进制数字看成一个关键字，即可认为k由3个关键字（kº，k¹，k²）组成，其中kº是百位数，k¹是十位数，k²是个位数。

基数排序

C#实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
public static int[] RadixSort(int[] arr)
{
    //数组中数字的最大位数
    int maxDigit = 0;

    //查找最大位数
    foreach (int item in arr)
    {
        int tempDigit = item.ToString().Length;
        if (tempDigit > maxDigit)
        {
            maxDigit = tempDigit;
        }
    }

    for (int i = 0; i < maxDigit; i++)
    {
        int[] tempArr = new int[arr.Length];
        int[] countArr = new int[10];

        for (int j = 0; j < arr.Length; j++)
        {
            //数组中每个元素在i位上的数字 = 该元素在<=i位的数字 - 该元素在<=(i-1)位的元素
            int splitNum = (int)(arr[j] / Math.Pow(10, i)) - (int)(arr[j] / Math.Pow(10, i + 1)) * 10;
            //累加每个元素在i位上的数字出现的次数，如12,118,92三个数字组成的数组，则当i==1（每个数字的十位）时，countArr[1] == 2, countArr[9] == 1，其余为0
            countArr[splitNum]++;
        }

        //累加在i位上出现j及比j小的数字的次数
        for (int j = 1; j < 10; j++)
        {
            countArr[j] += countArr[j - 1];
        }

        //从后向前遍历数组，根据每个元素i位上的数字(splitNum)，得到比该数字小或等于该数字的元素个数(countArr[splitNum])，即为该元素在排序后数组中的位置(splitNumIndex)
        for (int j = arr.Length - 1; j >= 0; j--)
        {
            int splitNum = (int)(arr[j] / Math.Pow(10, i)) - (int)(arr[j] / Math.Pow(10, i + 1)) * 10;
            int splitNumIndex = countArr[splitNum] - 1;
            tempArr[splitNumIndex] = arr[j];

            countArr[splitNum]--;
        }
        Array.Copy(tempArr, arr, tempArr.Length);
    }
    return arr;
}

总结：各排序算法的稳定性，时间、空间复杂度比较

总结

附：上述代码的调用示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
static void Main(string[] args)
{
    int[] arr = { 1, 51, 15, 15, 4, 18, 12, 54, 3, 53, 9, 58, 0, 26, 325, 7, 5, 56, 842, 785, 93, 65, 10, 87, 8, 66, 2, 12, 678, 35, 33, 32, 62, 624, 63, 6, 25, 8, 11, 89, 46 };
    int[] arrResult = Sort.RadixSort(arr);
    for (int i = 0; i < arrResult.Length; i++)
    {
        Console.Write(arrResult[i]);
        if (i < arrResult.Length - 1)
        {
            Console.Write(",");
        }
    }
    Console.Read();
}

参考资料：
八大排序算法
数据结构（c语言版）