### C#中的四种排序算法详解
#### 一、冒泡排序
冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，依次比较相邻的两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行的，直到没有再需要交换的元素为止，也就是说该数列已经排序完成。
**示例代码解析**:
```csharp
using System;
namespace BubbleSorter
{
public class BubbleSorter
{
public void Sort(int[] list)
{
int i, j, temp;
bool done = false;
j = 1;
while ((j < list.Length) && (!done))
{
done = true;
for (i = 0; i < list.Length - j; i++)
{
if (list[i] > list[i + 1])
{
done = false;
temp = list[i];
list[i] = list[i + 1];
list[i + 1] = temp;
}
}
j++;
}
}
}
public class MainClass
{
public static void Main()
{
int[] iArrary = new int[] { 1, 5, 13, 6, 10, 55, 99, 2, 87, 12, 34, 75, 33, 47 };
BubbleSorter sh = new BubbleSorter();
sh.Sort(iArrary);
for (int m = 0; m < iArrary.Length; m++)
{
Console.Write("{0}", iArrary[m]);
}
Console.WriteLine();
}
}
}
```
**关键点分析**:
1. **外层循环**: 控制排序轮次，每一轮都会确定一个元素的位置。
2. **内层循环**: 比较并交换相邻的元素，直到无需再交换为止。
3. **标志位(done)**: 用于检测某一轮是否发生了交换，如果没有发生交换，则提前结束排序过程。
#### 二、选择排序
选择排序算法的工作原理是：遍历数组找到最小（或最大）元素的索引，并将它与第一个位置的元素交换；接着，在剩下的子数组中重复这个过程，直到整个数组排序完成。
**示例代码解析**:
```csharp
using System;
namespace SelectionSorter
{
public class SelectionSorter
{
private int min;
public void Sort(int[] list)
{
for (int i = 0; i < list.Length - 1; i++)
{
min = i;
for (int j = i + 1; j < list.Length; j++)
{
if (list[j] < list[min])
{
min = j;
}
}
int t = list[min];
list[min] = list[i];
list[i] = t;
}
}
}
public class MainClass
{
public static void Main()
{
int[] iArrary = new int[] { 1, 5, 3, 6, 10, 55, 9, 2, 87, 12, 34, 75, 33, 47 };
SelectionSorter ss = new SelectionSorter();
ss.Sort(iArrary);
for (int m = 0; m < iArrary.Length; m++)
{
Console.Write("{0}", iArrary[m]);
}
Console.WriteLine();
}
}
}
```
**关键点分析**:
1. **查找最小值**: 在每个子数组中找到最小值的位置。
2. **交换**: 将找到的最小值与子数组的第一个元素交换位置。
#### 三、插入排序
插入排序的基本思想是：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
**示例代码解析**:
```csharp
using System;
namespace InsertionSorter
{
public class InsertionSorter
{
public void Sort(int[] list)
{
for (int i = 1; i < list.Length; i++)
{
int t = list[i];
int j = i;
while ((j > 0) && (list[j - 1] > t))
{
list[j] = list[j - 1];
--j;
}
list[j] = t;
}
}
}
public class MainClass
{
public static void Main()
{
int[] iArrary = new int[] { 1, 13, 3, 6, 10, 55, 98, 2, 87, 12, 34, 75, 33, 47 };
InsertionSorter ii = new InsertionSorter();
ii.Sort(iArrary);
for (int m = 0; m < iArrary.Length; m++)
{
Console.Write("{0}", iArrary[m]);
}
Console.WriteLine();
}
}
}
```
**关键点分析**:
1. **插入**: 将当前元素插入到合适的位置。
2. **移动**: 为当前元素腾出空间。
#### 四、希尔排序
希尔排序是对直接插入排序的一种改进。基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行一次直接插入排序。
**示例代码解析**:
```csharp
using System;
namespace ShellSorter
{
public class ShellSorter
{
public void Sort(int[] list)
{
int inc;
for (inc = 1; inc <= list.Length / 9; inc = 3 * inc + 1)
{
// 缺失后续代码，应包括增量逐步减少的过程以及具体的插入排序逻辑
}
}
}
public class MainClass
{
public static void Main()
{
// 缺失主函数调用代码
}
}
}
```
**关键点分析**:
1. **增量序列**: 使用不同的增量值来分组。
2. **插入排序**: 对每个子序列执行插入排序。
以上四种排序算法在C#中的实现展示了各自的特点和应用场合。这些算法虽然简单，但对于理解排序的基本概念和实现细节非常有帮助。在实际开发中，根据具体需求选择合适的排序算法至关重要。
