## 引言

**dynamic** 是 `Framework 4.0` 就出现特性，它的出现让 C# 具有了弱语言类型的特性。编译器在编译的时候不再对类型进行检查，默认 **dynamic** 对象支持开发者想要的任何特性。



## dynamic 介绍

在C#中，dynamic是一种类型，它允许你在运行时动态地确定对象的类型。

使用dynamic类型可以使代码更加灵活，因为不需要在编译时知道对象的确切类型，而可以在运行时根据需要确定类型。

### 确保dynamic对象调用有效

但是正因为你不知道对象的确切类型，所以在编码时一定要注意，确保对象的类型和属性和方法的存在，否则代码可能会引发运行时异常。

比如以下代码：

```csharp
static void Main(string[] args)
{
    dynamic dynamicObject = new Person();
    
    var attr1 = dynamicObject.Name;
    
    var attr2 = dynamicObject.GetAge();

    Console.ReadLine();
}


public class Person
{
    public string Gender { get; set; }
    
    public string Name { get; set; }
    
    public int MakeMoney()
    {
        return 200;
    }
}
```

上述在编译时是不会报错的，但是在运行时，执行第二句是没问题的，因为得到的 `dynamicObject` 对象是有 `Name` ，`Gender` 两个属性的，但是执行第三句时就会抛出异常 `Microsoft.CSharp.RuntimeBinder.RuntimeBinderException` ，并提示 `does not contain a definition for 'GetAge'`。

### dynamic 与 var

有时候会将 `var` 关键字与 `dynamic` 进行对比，那么我觉得主要有以下几点：
1.  `var` 用于在编译时推断变量类型，可以将其视为一种简写方式，将变量类型的声明推迟到编译时。而 `dynamic` 则是一种在运行时动态确定对象类型的类型。它允许您在运行时调用对象的属性和方法，而不需要在编译时确定对象的确切类型。
2.  `var`声明的变量在Visual Studio编译器中能够使用IntelliCode进行“智能提示”，因为Visual Studio编译器在此阶段是可以推断出其实际类型，而`dynamic` 类型的变量不可以进行”智能提示“。
3.  `var` 类型的变量可以使代码更加简洁和易于阅读，而使用 `dynamic` 类型的变量则可以使代码更加灵活和动态。 

## 使用 dynamic 简化反射

常规使用反射，调用上文中 `Person` 类 `MakeMoney()`方法，如下：

```csharp
Person person = new Person();

var method = typeof(Person).GetMethod("MakeMoney");

int moneys = (int)method.Invoke(person, null);
```
那如果使用 **dynamic** 进行简化，则像这样：

```csharp
dynamic person = new Person();

int moneys = person.MakeMoney();
```
这样使用 **dynamic** 后，代码更简洁，而且也减少了一次拆箱操作。

[基准测试工具 --- BenchmarkDotNet](https://niuery.com/post/58)这篇文章中，介绍了使用 **BenchmarkDotNet** 来测试性能，接下来依然使用 **BenchmarkDotNet** 来测试以下，测试一下执行100000次，上述两种方式的区别：

```csharp
static void Main(string[] args)
{
    BenchmarkRunner.Run<BenchmarkTest>();
}

[SimpleJob(RunStrategy.ColdStart, iterationCount: 100000)]
[MemoryDiagnoser]
public class BenchmarkTest
{
    [Benchmark()]
    public int UseReflection()
    {
        Person person = new Person();

        var method = typeof(Person).GetMethod("MakeMoney");

        int moneys = (int)method.Invoke(person, null);

        return moneys;
    }

    [Benchmark()]
    public int UseDynamic()
    {
        dynamic person = new Person();

        int moneys = person.MakeMoney();

        return moneys;
    }
}

```

看一下 **BenchmarkDotNet** 测试结果，从报告中能看出来，使用 Dynamic 方式的方法的平均执行时间（Mean）和内存分配（AllLocated）时远小于使用反射实现的。

![image.png](https://niuery.com/static/img/6525a4af3162ab178d8351644358b473.image.png)


## 结论

在相同数量级的反射实现和使用 Dynamic 方式实现， Dynamic 方式在执行时间或内存分配或代码简洁都是有优势的，所以**推荐使用 dynameic 来简化反射实现**。

编码技巧 --- 使用dynamic简化反射

## 介绍

今天介绍一个非常强大的基于.Net 的基准测试工具[BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet)。

**BenchmarkDotNet** 已经被14300多个项目采用，包括非常多的知名开源项目，例如
- dotnet/performance（.Net所有运行时的基准测试项目）
- dotnet/runtime（.Net 运行时库），
- Roslyn (c#和Visual Basic编译器)，
- Mono、 ASP.NET Core、 ML.NET、 Entity Framework Core、 PowerShell SignalR、 f#、 Orleans, Newtonsoft.Json、Elasticsearch.Net、Dapper等诸多知名开源项目。



**BenchmarkDotNet**能够自动在所有运行时运行基准，汇总测试结果，并打印一个汇总表，其中包含众多基准信息：

![image.png](https://niuery.com/static/img/88011dbb5e07b75259d13fa4c02d71e4.image.png)

这些测试数据也可以导出为不同的格式(md, html, csv, xml, json等)，包括图片:

![image.png](https://niuery.com/static/img/c88bdd3cc5033da6d139913e4ebba4b3.image.png)

最主要的是它可以非常容易的编写基准测试，只需要安装好NuGet包之后，给需要测试的方法标注 `Attribute`，就可以执行测试。

## Demo
这里可以使用控制台或单元测试来进行测试。

官方GitHub上分别提供了基于控制台和基于XUnit单元测试的基准测试：
- [基于控制台Demo](https://github.com/dotnet/BenchmarkDotNet/tree/master/samples/BenchmarkDotNet.Samples)(https://github.com/dotnet/BenchmarkDotNet/tree/master/samples/BenchmarkDotNet.Samples)
- [基于Xunit单元测试Demo](https://github.com/dotnet/BenchmarkDotNet/tree/master/tests/BenchmarkDotNet.IntegrationTests)(https://github.com/dotnet/BenchmarkDotNet/tree/master/tests/BenchmarkDotNet.IntegrationTests)

接下来，以一个基于控制台的基准测试来讲解一下：

```csharp
class Program
{
    static void Main(string[] args)
    {
        BenchmarkRunner.Run<BenchmarkTest>();
    }
}

[SimpleJob(RunStrategy.ColdStart, iterationCount: 100000)]
public class BenchmarkTest
{
    [Benchmark()]
    public void CreateTuple()
    {
        var temp = new Tuple<int, string>(1, "");
    }
}
```

上述代码中，创建了一个 `BenchmarkTest` 类用于做基准测试，然后创建了一个 `CreateTuple()`方法，该方法创建一个 `Tuple` 对象，然后我们给这个方法标记 `[Benchmark()]` ,标记该方法用于做基准测试，然后在`BenchmarkTest` 类上标记 `[SimpleJob(RunStrategy.ColdStart, iterationCount: 100000)]`，表示是以冷启动的方式，执行该类要测试的基准方法100000次。

接下来，来看一下测试结果，输出：

![image.png](https://niuery.com/static/img/c2a7420ee028fcb436120ed92fbba760.image.png)

## 讲解

可以看到控制台输出分为了几个部分。

### Summary

可以看到控制台输出中黄色部分加下方表格，就是该报告主要内容，能看到当前执行测试时的运行环境，测试条件（IterationCount=100000  RunStrategy=ColdStart），表格中也能看到具体性能，比如，
1. Method(测试方法的名称为CreateTuple)。
2. Mean（测试运行的平均时间为420.7纳秒）。
3. Error(测试运行的标准误差为16.96纳秒)。
4. StdDev(所有测试运行的标准偏差为1630纳秒)。
5. Median(所有测试运行的中位数为300纳秒)。



### Legends

简单描述了表格中的一些参数。

实际上在 `BenchmarkDotNet` 中，这样的统计数据列大概有90多条，可以[参考这里](https://github.com/dotnet/BenchmarkDotNet/blob/master/src/BenchmarkDotNet/Columns/Column.cs)(https://github.com/dotnet/BenchmarkDotNet/blob/master/src/BenchmarkDotNet/Columns/Column.cs)

下面挑出一些常用统计列，简单解释：

- Method: 测试方法的名称。
- Mean: 所有测试运行的平均时间。
- Error: 测试运行的标准误差，标准误差是测试结果的离散程度的度量，标准误差越小，表示测试结果越稳定。
- StdDev: 所有测试运行的标准偏差，标准偏差是测试结果的离散程度的度量，标准偏差越小，表示测试结果越接近平均值。
- Median: 所有测试运行的中位数。中位数是测试结果的中间值，如果测试结果的个数为奇数，则中位数为中间的那个值；如果测试结果的个数为偶数，则中位数为中间两个值的平均值。
- Ratio: 每个测试运行的平均时间与基准测试运行的平均时间的比值。基准测试是性能最好的测试，它的比值为 1.0。其他测试的比值表示它们相对于基准测试的性能表现，比值越小，表示性能越好。
- RatioSD: 所有测试运行的比值的标准偏差。标准偏差越小，表示比值的离散程度越小，测试结果更稳定。
- Gen 0: 所有测试运行期间生成的第 0 代垃圾回收的次数。垃圾回收是 .NET 运行时自动回收不再使用的内存的机制，Generational Garbage Collection 是 .NET 中的一种垃圾回收算法。
- Gen 1: 所有测试运行期间生成的第 1 代垃圾回收的次数。
- Gen 2: 所有测试运行期间生成的第 2 代垃圾回收的次数。
- Allocated: 所有测试运行期间分配的内存总量。

### Warings

会给出一些警告，或者建议操作，像示例代码中生成100000个 `Tuple` 对象，他就报警方法执行实现太短，建议使用更多操作将其增加到至少100.0000 ms。

### Export
上面其实还有一部分控制台内容是 **Export** 内容 ,如下图所示：

![image.png](https://niuery.com/static/img/6cd7d808396959b3f2985fd3420a34e1.image.png)

默认给你生成了三种格式的报告，CSV格式，Markdownn格式，和Html格式，生成路径是运行根目录下的`BenchmarkDotNet.Artifacts\results\`文件夹下的 `BenchmarkDotNet.Console.BenchmarkTest-report`文件。

![image.png](https://niuery.com/static/img/937b599bbf4e631fca5d09965a572021.image.png)

## 总结
本篇抛砖引玉，只讲述基于控制台做基准测试，强烈建议各位看官阅读Github上的示例，学会使用更多的参数，借助 `BenchmarkDotNet` 做出更准确准确、更可靠的性能测试结果。


>参考
>
>BenchmarkDotNet Github地址：https://github.com/dotnet/BenchmarkDotNet
>
>基于控制台Demo Github地址：https://github.com/dotnet/BenchmarkDotNet/tree/master/samples/BenchmarkDotNet.Samples
>
>基于Xunit单元测试Demo Github地址：https://github.com/dotnet/BenchmarkDotNet/tree/master/tests/BenchmarkDotNet.IntegrationTests
>
>统计数据列参考 Githu地址：https://github.com/dotnet/BenchmarkDotNet/blob/master/src/BenchmarkDotNet/Columns/Column.cs

基准测试工具 --- BenchmarkDotNet

## 引言

上一篇[数据结构与算法 --- 排序算法（一）](https://niuery.com/post/54)中，学习了冒泡排序，插入排序，选择排序这三种时间复杂度为 $O(n^2)$ 的算法。实时上 $O(n^2)$ 时间复杂度是非常高的，所以一般只适合小规模数据排序，那接下来，就在看一看时间复杂度为 $O(nlog)$ 的算法：归并排序和快速排序。
 

## 分治算法思想

归并排序和快速排序的核心思想就是分治算法思想，所以先介绍一下分治算法思想：

**分治算法思想简单来说就是将一个复杂的问题分解成几个较简单的子问题，再递归地解决这些子问题**。通常遵循以下三个步骤:

- 分解：将问题分解成几个较小的子问题，这些子问题必须是相同类型的问题，且解决这些子问题必须可以解决原问题。

- 解决：递归地解决各个子问题，如果子问题足够小可以直接解决则解决，否则继续分解。

- 合并：将子问题的解合并为原问题的解。

## 归并排序
归并排序（Merge Sort）是一种基于分治思想的排序算法。它的基本思路是将待排序的数组分成两个子序列，然后对每个子序列进行递归排序，最后将排好序的两个子序列合并成一个有序序列。
### 算法图解
来看一下归并排序的执行过程如下图：

![image.png](https://niuery.com/static/img/564d9fac8cfc2e08719bdca0ffffa6fb.image.png)

接下来考虑如何使用C#代码实现一个归并排序算法？

一般归并排序就是通过递归实现的，那么在[数据结构与算法 --- 递归（一）](https://niuery.com/post/51)中总结了递归代码的编写技巧：写递推公式，寻找终止条件，最后将递推公式翻译为代码。

那么看一下归并排序的递归代码的递推公式为：


$$
merge\_sort(p,r)=merge(merge(p,q),merge(q+1,r)),  \quad (p<q<r)
$$
其终止条件为:$p\ge r$。

公式中 $ merge\_sort(p,r) $ 表示对下标从 $p$ 到 $r$ 的数组数据进行归并排序，然后将这个问题拆分成了两个子问题： $merge(p,q)$ 和 $merge(q+1,r)$ ，其中下标 $q$ 表示 $p$ 到 $r$ 的中间位置，也就是$\frac{p+r}{2}$，当这两个子数组排好序之后，再将这两个有序子数组合并（$merge()$），就完成了该数组的排序。

这里还需要着重讲解一下两个有序子数组的合并，实际上一般在这里合并方法使用的是双指针法，双指针法是合并两个有序数组最高效的算法，其时间复杂度为 $O(m+n)$，其中 m 和 n 分别是两个数组的长度。
具体实现步骤如下：

1. 定义两个指针 i 和 j，分别指向两个有序数组的起始位置。
2. 定义一个空数组 temp，用于存储合并后的有序数组。
3. 比较两个指针所指的元素大小，将较小的元素加入 temp 数组中，并将对应的指针向后移动一位。
4. 重复步骤 3，直到其中一个指针超出了数组的范围。
5. 将另一个数组中剩余的元素加入 temp 数组中。
6. 最后将temp中的元素拷贝回arr中,完成排序。

综上，用C#代码实现一个归并算法如下：

```csharp
public static void MergeSort(int[] arr, int left, int right)
{
    if (left < right)
    {
        int mid = (left + right) / 2;
        //将待排序的数组分成两个子序列进行递归排序
        MergeSort(arr, left, mid);
        
        MergeSort(arr, mid + 1, right);
        //合并
        Merge(arr, left, mid, right);
    }
}

public static void Merge(int[] arr, int left, int mid, int right)
{
    //双指针法合并数据到temp数组
    int i = left, j = mid + 1, k = 0;
    
    int[] temp = new int[right - left + 1];
    
    while (i <= mid && j <= right)
    {
        if (arr[i] <= arr[j])
        {
            temp[k] = arr[i];
            i++;
        }
        else
        {
            temp[k] = arr[j];
            j++;
        }
        k++;
    }
    //当一边遍历完成后,将另一边剩余元素直接放入temp。
    while (i <= mid)
    {
        temp[k] = arr[i];
        i++;
        k++;
    }
    while (j <= right)
    {
        temp[k] = arr[j];
        j++;
        k++;
    }
    for (int p = 0; p < k; p++)
    {
        arr[left + p] = temp[p];
    }
}

```

数据结构与算法 --- 排序算法（二）

## 灵感

最近在做配置模块，然后整个配置的参数是非常多的，层级结构也很深。可能有几百个参数，三、四层的层级关系，想要捋顺所有的类和参数，太繁琐了，而且 Visual Studio 的类视图只能看到属性，却看不出层级关系来，所以花费些许精力，写一个控制台小程序，展示类结构。



原理就是通过反射得到所有属性，遍历展示，有层级关系的递归展示。

代码如下：

```csharp
public static void PrintProperties(object obj, int indentLevel, ref StringBuilder sb)
{
    try
    {
        var type = obj.GetType();

        var properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);

        foreach (var property in properties)
        {
            string[] arr = new string[] { "", "", "" };

            if (property.PropertyType.IsClass && property.PropertyType != typeof(string))
            {
                var value = property.GetValue(obj);

                if (value == null && !property.PropertyType.IsArray)
                {
                    value = Activator.CreateInstance(property.PropertyType);
                }
                // 判断属性的类型是否为泛型类型
                if (property.PropertyType.IsGenericType)
                        {

                            // 获取属性的泛型类型定义
                            var typeDefinition = property.PropertyType.GetGenericTypeDefinition();

                            Type[] typeArgs = value.GetType().GetGenericArguments();

                            var temp = Activator.CreateInstance(typeArgs[0]);

                            // 判断泛型类型是否为 IEnumerable<T>
                            if (typeDefinition == typeof(IEnumerable<>))
                            {
                                arr[0] = "IEnumerable<";
                                arr[1] = typeArgs[0].Name;
                                arr[2] = "> ";
                            }
                            else if (typeDefinition == typeof(List<>))
                            {
                                arr[0] = "List<";
                                arr[1] = typeArgs[0].Name;
                                arr[2] = "> ";
                            }

                            // 判断泛型类型是否为 ICollection<T>
                            else if (typeDefinition == typeof(ICollection<>))
                            {
                                arr[0] = "ICollection<";
                                arr[1] = typeArgs[0].Name;
                                arr[2] = "> ";
                            }
                            else if (typeDefinition == typeof(Dictionary<,>))
                            {
                                arr[0] = "Dictionary<";
                                arr[1] = string.Join(",", typeArgs.Select(t => t.Name));
                                arr[2] = "> ";

                            }

                            sb.Append(new string(' ', indentLevel * 4));
                            sb.AppendLine("- " + string.Join("", arr) + property.Name);

                            PrintProperties(temp, indentLevel + 1, ref sb);
                        }
                else
                {
                    arr[0] = "";
                    arr[1] = property.PropertyType.Name;
                    arr[2] = " ";

                    sb.Append(new string(' ', indentLevel * 4));
                    sb.AppendLine("- " + string.Join("", arr) + property.Name);
                    //如果是数组，就不需要在递归
                    if (!property.PropertyType.IsArray)
                        PrintProperties(value, indentLevel + 1, ref sb);
                }
            }
            else
            {
                arr[0] = "";
                arr[1] = property.PropertyType.Name;
                arr[2] = " ";

                sb.Append(new string(' ', indentLevel * 4));
                sb.AppendLine("- " + string.Join("", arr) + property.Name);
            }
        }
    }
    catch (Exception ex)
    {

        throw;
    }
}


```

实例图：

![image.png](https://niuery.com/static/img/d6b1eb9278d8f80dd56f22d2e43e5b32.image.png)

小工具 --- 树形展示多属性复杂结构类

## 引言
按照时间复杂度，将一些常见排序算法进行分类，分为以下三类：
- $O(n^2)$：冒泡排序，插入排序，选择排序。

- $O(nlogn)$：快速排序，归并排序。

- $O(n)$：桶排序，计数排序，基数排序。

本篇文章讨论以下第一类：冒泡排序，插入排序，选择排序。


上一篇[数据结构与算法 --- 如何分析排序算法](https://niuery.com/post/53)提到，从三个方面分析排序算法：

- 排序算法的执行效率 - 时间复杂度

- 排序算法的内存消耗 -  原地排序算法/非原地排序算法

- 排序算法的稳定性 - 稳定排序算法/不稳定排序算法


那么，下面讨论一下这三种排序算法。

## 冒泡算法
**冒泡排序（bubble sort）过程包含多次冒泡操作，每一次冒泡操作都会遍历整个数组，依次比较相邻元素，不符合大小关系则互换位置，直到无元素需要交换。**

### 算法图解
那来看一下排序过程，假设有一组数据：1、6、9、3、7、2，按照从小到大的排序顺序排序，则第一轮的冒泡操作如下图：


![image.png](https://niuery.com/static/img/d34290c2a34afa51fdccb3f288a1b817.image.png)

这样，最大的数已经排在最后一个了，在完成其他五个数的排序，在进行五次这样的冒泡操作就排序完成，如下图：

![image.png](https://niuery.com/static/img/3f67c77d1cc4f3257696af4bee6ba044.image.png)

但是从上图也可以看出，在第四次冒泡的时候就已经排序完成，其实可以进行优化。当某一次冒泡操作已经没有数据交换时，说明已经排序完成，可以结束排序。

那么，使用C#实现一个冒泡排序如下：

```csharp
public void BubbleSort(int[] arr)
{
    if (arr == null || arr.Length == 0)
        return;

    var length = arr.Length;
    //提前结束排序的标志
    bool flag = false;

    for (int i = 0; i < length; i++)
    {
        for (int j = 0; j < length - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                //交换元素
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;

                flag = true;
            }
        }
        //如果没有数据交换，则提前退出
        if (!flag)
            break;
    }
}

```

### 算法分析
1. 稳定性
   
   冒泡排序只涉及到相邻数据交换，只需要常量级的临时空间，空间复杂度为$O(1)$，是一个原地排序算法。
2. 内存消耗

   冒泡排序中，只有交换才可以改变两个元素的前后顺序，为了保证冒泡排序的稳定性，在冒泡过程中，我们对两个大小相等的相邻的元素不做交换，这就保证了相同大小的元素顺序在排序后不会改变。因此冒泡排序是一个稳定排序算法。
3. 时间复杂度
   
   最好的情况下，要排序的数据已经是有序的了，我们只需要进行一次冒泡操作，所以最好时间复杂度为$O(1)$。
   
   最坏的情况下，要排序的数据是倒序排列的，则需要 $n$ 次冒泡操作，因此最坏时间复杂度为$O(n^2)$。
   
   对于平均时间复杂度，假设有 $n$ 个数据的集合，有 $n!$ 种不同的排列方式，所以很难直接计算时间复杂度。
   
所以计算排序算法的时间复杂度，需要另外一种思路：通过“有序度”和“无序度”这两个概念来进行分析：

- 有序度
    
    **有序度是指数组中具有有序关系的元素对的个数**，如果用数学式表达出来，就是：
    $$
    a[i] \leq a[j], \quad i<j
    $$
                              
- 逆序度
                              
    **逆序度则跟有序度定义相反，是指数组中逆序元素对的个数（假设从小到大为有序）** ，如果用数学式表达出来，就是：
    $$
    a[i] > a[j], \quad i<j  
    $$   

有序度和你序度使用图片表示出来如下图：  
   
![image.png](https://niuery.com/static/img/6e4452e5f75d8064836f72df22037693.image.png)
   
 还有一个概念，当数组是一个倒叙（假设从小到大的为有序）的排列的数组时，有序度为0，逆序度为$\frac{n(n-1)}{2}$（该公式为排列组合公式），也就是15，当它时一个完全有序的数组时，有序度为$\frac{n(n-1)}{2}$，逆序度为0，像这种完全有序的数据的有序度称之为满有序度（$\frac{n(n-1)}{2}$）。
   
从上述定义中，也可以看出，数组的有序度，逆序度，满有序度存在一定关系：**逆序度 \= 满有序度 \- 有序度**>。排序的过程就是增加有序度，减少逆序度的过程。当最终有序度达到满有序度时，说明已经排序完成。

所以补充上述排序过程中有序度变化如下图：

      
![image.png](https://niuery.com/static/img/c8d8da1634fac0a70be2c3d63fb5bc57.image.png)
可以看到冒泡排序只有比较和交换两个操作，因为交换只会交换相邻两个元素，所以每一次交换，有序度就增加1。无论冒泡算法如何改进，它的总交换数是固定的，这个数也是逆序度，所以上图排序过程中的满排序度是15（$\frac{6(6-1)}{2}$），初始有序度为8，所以上述排序过程共进行了7次交换操作。

那么，有了有序度和逆序度两个概念后，对于包含$n$个数据的数组进行冒泡排序，平均交换次数是多少呢？
    
最坏情况下，初始有序度为0，因此要进行 $\frac{n(n-1)}{2}$ 次交换。

最好情况下，初始有序度为 $\frac{n(n-1)}{2}$ ，不需要交换。
    
我们可以取中间值 $\frac{n(n-1)}{4}$ ，意味着要进行交换操作的量级是 $n^2$ 。而比较操作肯定要比交换操作多，复杂度的上限是 $O(n^2)$ （最坏时间复杂度），因此比较操作的量级也是 $n^2$ ，综合比较和交换两部分操作，冒泡排序的平均情况下的时间复杂度为 $O(n^2)$。
    

:::warning{title="注意"}
该方式推导平均时间复杂度其实并不严格，但是概率论的定量分析太复杂，这样的方式在一定程度上是实用的。
:::

## 插入排序
    
先思考一下，对于一个有序数组（假设数组从小到大），往里边添加一个数后，如何让数组仍然保持有序？

答案其实简单，遍历数组，直到找到比它大的，站在它前边就好了，往后的都退一步都往后稍一稍就行，哈哈。
像这样：

这样的方案其实就是维护一个动态数组有序的方法，即动态的往有序集合中添加数据。

对于一个静态数据，也可以使用这种插队的方式来进行排序，于是就有了插入排序算法（insertion sort）。

那么如何实现插入排序：首先，可以将数组中的元素分为两个区间，已排序区间和未排序区间，初始已排序区间只有一个元素，就是数组的第一个元素，插入排序的核心思想是取未排序区间的元素，在已排序区间中找合适的位置插入，并保证已排序区间一直有序，重复该过程，直到未排序区间中元素未空。

### 算法图解
    
如下图：

![image.png](https://niuery.com/static/img/892c86dce9d719428839d399529622ca.image.png)


插入排序过程包含两种基本操作：元素的比较和移动。当我们需要将一个数据 a 插入到已排序区间时，需要用数据 a 与已排序区间的数据依次比较大小，找到合适的插入点。在找到插入点之后，我们还需要将插入点之后的数据顺序往后移动一位，这样才能腾出位置给数据 a 插入。对于不同的查找插入点方法(从头到尾、从尾到头)，总的比较次数是有区别的。但对于一个给定的初始序列，移动操作的总次数是固定的，就等于数组的逆序度。


为什么说移动次数就等于逆序度呢？

如下图所示，满有序度为 $\frac{n(n-1)}{2}=15$，初始有序度为8，逆序度为7，在下图中移动元素的个数之和也等于7（$2+1+4=7$） 

![image.png](https://niuery.com/static/img/d70f66340129601e74a117db5097ab5e.image.png)
与冒泡排序算法一样，我们再来回答下面 3 个问题。
通过原理介绍和代码实现，我们可以很明显地看出，插入排序的运行过程并不需要额外的存储空间，因此，它是原地排序算法。同时，它的空间复杂度也是 $O(1)$。

那么，使用C#实现一个插入排序如下：

```csharp
public static void InsertionSort(int[] arr)
{
    if (arr == null || arr.Length == 0) return;

    var length = arr.Length;

    //从第二个元素开始比较（未排序区间）
    for (int i = 1; i < length; i++)
    {
        var val = arr[i];

        //遍历已排序区间
        for (int j = i - 1; j >= 0; j--)
        {
            //按从小到大排序，所以如果目标元素比已排序元素小，则已排序区间往后移动一位
            if (arr[j] > val)
            {
                arr[j + 1] = arr[j];
            }
            else
            {
                arr[j + 1] = val;
                break;
            }
        }
    }
}

```
### 算法分析
接下来分析一下插入排序算法：

第一，插入排序是原地排序算法吗？

插入排序的过程只有移动元素，并不会创建额外存储空间，因此，它是原地排序算法，且空间复杂度为$O(1)$。


第二，插入排序是稳定排序算法吗？

对于未排序区间的某个元素，如果在已排序区间存在与它值相同的元素，我们选择将它插入到已排序区间值相同元素的后面，这样就可以保持值相同元素原有的前后顺序不变，因此插入排序是稳定排序算法。

第三，插入排序的时间复杂度是多少？

如果要排序的数据已经是有序的，我们就不需要移动任何数据。如果我们选择从尾到头在已排序区间里查找插入位置，那么每次只需要比较一个数据就能确定插入位置。因此，综合元素移动和比较的次数，最好时间复杂度为 $O(n)$。

如果数组是倒序的，那么每次插入都相当于在数组的第一个位置插入新的数据。因此，需要移动大量的数据，最坏时间复杂度为 $O(n^2)$。

还记得我们在数组中插入一个数据的平均时间复杂度是多少吗? 

没错，是 $O(n)$ 。因此对于插入排序，每次插入操作都相当于在数组中插入一个数据，循环执行 $n$ 次插入操作，因此，平均时间复杂度为  $O(n^2)$。
    
## 选择排序

选择排序 (selection sort) 的实现思路类似插入排序，也将整个数组划分为已排序区间和未排序区间。两者的不同点在于: 选择排序每次从未排序区间中找到最小的元素，将其放到已排序区间的末尾。

### 算法图解

选择排序图解如下：

![image.png](https://niuery.com/static/img/31636599a2e60bc3b41d92de7e039210.image.png)

使用C#实现一个选择排序如下：

```csharp
public static void SelectionSort(int[] arr)
{
    if (arr == null || arr.Length == 0) return;

    var length = arr.Length;
    //只需循环length - 1次
    for (int i = 0; i < length - 1; i++)
    {
        int minPos = i;
        //找出最小值的索引
        for (int j = i; j < length; j++)
        {
            if (arr[j] < arr[minPos])
            {
                minPos = j;
            }
        }
        //交换元素
        int temp = arr[i];
        arr[i] = arr[minPos];
        arr[minPos] = temp;
    }
}    
```
                                     
### 算法分析
                                     
这里不再做详细分析，首先，它排序过程中没有产生额外存储空间，空间复杂度为 $O(1)$，是一种原地排序算法。
                                     
选择排序的最好时间复杂度、最坏时间复杂度、平均时间复杂度都为 $O(n^2)$。

那么选择排序是稳定排序算法吗？
                                     
选择排序是不稳定排序算法。从图解中可以看出，选择排序每次要找剩余未排序元素中的最小值，然后与前面的元素交换位置。这里的交换操作破坏了排序算法的稳定性。例如5、8、5、2、9这样一组数据，使用选择排序来排序的话，第一次找到最小的元素是 2，与第一个元素 5 交换位置，那么第一个 5 和中间的 5 的原有的先后顺序就改变了，因此，选择排序就是不稳定的了。
                           
> 参考资料
> 
> [1] 数据结构与算法之美 / 王争 著. --北京：人民邮电出版社，2021.6