C# 十大经典排序算法
时间: 2023-11-22 21:38:24 浏览: 64
C# 的十大经典排序算法包括二叉树排序、快速排序、希尔排序、插入排序、冒泡排序、选择排序等。这些算法都有自己的特点和适用场景。二叉树排序是一种基于二叉树的排序算法,它通过构建排序二叉树来实现排序。快速排序是一种基于分治思想的排序算法,它通过选择一个基准元素将序列划分成两个子序列,并递归地对子序列进行排序。希尔排序是一种插入排序的改进算法,它通过将序列分组并分别进行插入排序来提高排序效率。插入排序是一种简单直观的排序算法,它通过将元素逐个插入到已排序序列中的正确位置来实现排序。冒泡排序是一种基于比较和交换的排序算法,它通过多次遍历序列并比较相邻元素的大小来实现排序。选择排序是一种简单直观的排序算法,它通过选择最小(或最大)元素并将其放置在已排序序列的末尾来实现排序。
相关问题
c# 排序算法
C# 中常用的排序算法有以下几种:
1. 冒泡排序
冒泡排序是一种简单的排序算法,每次比较相邻两个元素的大小并交换位置,重复进行直到数组有序。具体实现如下:
```csharp
public static void BubbleSort(int[] arr)
{
int n = arr.Length;
for (int i = 0; i < n - 1; i++)
{
for (int j = 0; j < n - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
```
2. 插入排序
插入排序是一种简单且有效的排序算法,将未排序的元素依次插入到已排序的序列中,直到所有元素都有序。具体实现如下:
```csharp
public static void InsertionSort(int[] arr)
{
int n = arr.Length;
for (int i = 1; i < n; i++)
{
int key = arr[i];
int j = i - 1;
while (j >= 0 && arr[j] > key)
{
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
```
3. 选择排序
选择排序是一种简单的排序算法,每次选择数组中最小的元素并将其放到已排序的序列的末尾,直到所有元素都有序。具体实现如下:
```csharp
public static void SelectionSort(int[] arr)
{
int n = arr.Length;
for (int i = 0; i < n - 1; i++)
{
int minIndex = i;
for (int j = i + 1; j < n; j++)
{
if (arr[j] < arr[minIndex])
{
minIndex = j;
}
}
int temp = arr[minIndex];
arr[minIndex] = arr[i];
arr[i] = temp;
}
}
```
4. 快速排序
快速排序是一种高效的排序算法,它使用分治的思想将数组分成两个子数组,然后递归地对这两个子数组进行排序,最后合并两个有序数组。具体实现如下:
```csharp
public static void QuickSort(int[] arr, int left, int right)
{
if (left < right)
{
int pivotIndex = Partition(arr, left, right);
QuickSort(arr, left, pivotIndex - 1);
QuickSort(arr, pivotIndex + 1, right);
}
}
private static int Partition(int[] arr, int left, int right)
{
int pivot = arr[right];
int i = left - 1;
for (int j = left; j < right; j++)
{
if (arr[j] < pivot)
{
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp1 = arr[i + 1];
arr[i + 1] = arr[right];
arr[right] = temp1;
return i + 1;
}
```
C#写个快速排序算法
好的,下面是C#实现的快速排序算法:
```csharp
public static void QuickSort[] arr, int left, int right)
{
if (left < right)
{
int pivot = Partition(arr, left, right);
QuickSort(arr, left, pivot - 1);
QuickSort(arr, pivot + 1, right);
}
}
public static int Partition(int[] arr, int left, int right)
{
int pivot = arr[right];
int i = left - 1;
for (int j = left; j < right; j++)
{
if (arr[j] <= pivot)
{
i++;
Swap(arr, i, j);
}
}
Swap(arr, i + 1, right);
return i + 1;
}
public static void Swap(int[] arr, int i, int j)
{
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
```
调用方法:
```csharp
int[] arr = { 5, 3, 8, 6, 2, 7, 1, 4 };
QuickSort(arr, 0, arr.Length - 1);
```
注:以上代码是基于单线程的快速排序算法实现。