1、冒泡排序（Bubble Sort）：
冒泡排序是一种简单的排序算法。它重复地遍历要排序的列表，比较相邻的两个元素，并交换它们的位置，直到列表排序完成为止。每次遍历都会将最大的元素移动到列表的末尾。冒泡排序算法的时间复杂度为O(n^2)。
2、插入排序（Insertion Sort）：
插入排序通过构建一个有序序列，依次将列表中的元素插入到适当的位置来实现排序。从第一个元素开始，它会与已排序序列中的元素进行比较，并将其插入到正确的位置。插入排序算法的时间复杂度为O(n^2)。
3、选择排序（Selection Sort）：
选择排序是一种简单直观的排序算法。它将列表分为已排序和未排序两部分。每次选择未排序部分的最小元素，并将其放到已排序部分的末尾，逐步构建有序序列。选择排序算法的时间复杂度为O(n^2)。
4、快速排序（Quick Sort）：
快速排序是一种高效的排序算法，在大多数情况下都比冒泡排序、插入排序和选择排序更快。它使用分治法的思想，通过选择一个基准元素，将列表分成两个子列表，并对每个子列表递归地进行排序。快速排序算法的时间复杂度为O(nlogn)。
5、归并排序（Merge Sort）：
归并排序是一种稳定的排序算法。它将列表分成较小的子列表，对每个子列表进行排序，然后再将子列表合并成较大的有序列表，直到整个列表排序完成。归并排序算法的时间复杂度为O(nlogn)。
6、堆排序（Heap Sort）：
堆排序是一种利用堆数据结构的排序算法。它通过构建一个二叉堆，在堆的性质下进行排序。堆排序分为两个阶段：建堆和排序。建堆阶段将无序列表转换为堆，排序阶段将堆的根节点依次取出，并调整堆，完成排序。堆排序算法的时间复杂度为O(nlogn)。
以上所述排序算法均以升序为例，也可以针对降序进行相应的修改。这些排序算法可以根据具体的需求选择使用，每种算法都有自己的优点和缺点，需要根据数据规模和性能要求进行选择。
C# 常见排序算法的完整代码示例：
1、冒泡排序（Bubble Sort）:
public 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、插入排序（Insertion Sort）:
public 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、选择排序（Selection Sort）:
public void SelectionSort(int[] arr)
{
int n = arr.Length;
for (int i = 0; i < n - 1; i++)
{
int minIdx = i;
for (int j = i + 1; j < n; j++)
{
if (arr[j] < arr[minIdx])
{
minIdx = j;
}
}
int temp = arr[minIdx];
arr[minIdx] = arr[i];
arr[i] = temp;
}
}
4、快速排序（Quick Sort）:
public void QuickSort(int[] arr, int low, int high)
{
if (low < high)
{
int pivot = Partition(arr, low, high);
QuickSort(arr, low, pivot - 1);
QuickSort(arr, pivot + 1, high);
}
}
private int Partition(int[] arr, int low, int high)
{
int pivot = arr[high];
int i = low - 1;
for (int j = low; j < high; j++)
{
if (arr[j] < pivot)
{
i++;
int temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
int temp2 = arr[i + 1];
arr[i + 1] = arr[high];
arr[high] = temp2;
return i + 1;
}
5、归并排序（Merge Sort）:
public void MergeSort(int[] arr, int low, int high)
{
if (low < high)
{
int mid = (low + high) / 2;
MergeSort(arr, low, mid);
MergeSort(arr, mid + 1, high);
Merge(arr, low, mid, high);
}
}
private void Merge(int[] arr, int low, int mid, int high)
{
int n1 = mid - low + 1;
int n2 = high - mid;
int[] L = new int[n1];
int[] R = new int[n2];
for (int i = 0; i < n1; ++i)
L[i] = arr[low + i];
for (int j = 0; j < n2; ++j)
R[j] = arr[mid + 1 + j];
int k = low;
int p = 0, q = 0;
while (p < n1 && q < n2)
{
if (L[p] <= R[q])
{
arr[k] = L[p];
p++;
}
else
{
arr[k] = R[q];
q++;
}
k++;
}
while (p < n1)
{
arr[k] = L[p];
p++;
k++;
}
while (q < n2)
{
arr[k] = R[q];
q++;
k++;
}
}
6、堆排序（Heap Sort）:
public void HeapSort(int[] arr)
{
int n = arr.Length;
for (int i = n / 2 - 1; i >= 0; i--)
{
Heapify(arr, n, i);
}
for (int i = n - 1; i >= 0; i--)
{
int temp = arr[0];
arr[0] = arr[i];
arr[i] = temp;
Heapify(arr, i, 0);
}
}
private void Heapify(int[] arr, int n, int i)
{
int largest = i;
int left = 2 * i + 1;
int right = 2 * i + 2;
if (left < n && arr[left] > arr[largest])
{
largest = left;
}
if (right < n && arr[right] > arr[largest])
{
largest = right;
}
if (largest != i)
{
int temp = arr[i];
arr[i] = arr[largest];
arr[largest] = temp;
Heapify(arr, n, largest);
}
}
以上是常见的排序算法的C#代码示例。你可以根据需要使用这些算法来对数组进行排序。