• C#经典十大排序算法（完结）

    C#冒泡排序算法

    简介

    冒泡排序算法是一种基础的排序算法，它的实现原理比较简单。核心思想是通过相邻元素的比较和交换来将最大（或最小）的元素逐步"冒泡"到数列的末尾。

    详细文章描述

    https://mp.weixin.qq.com/s/z_LPZ6QUFNJcwaEw_H5qbQ

    代码实现

    1.         /// <summary>
    2.         /// 递归方式实现冒泡排序
    3.         /// </summary>
    4.         /// <param name="arr">arr</param>
    5.         /// <param name="arrLength">arrLength</param>
    6.         public static void RecursiveBubbleSort(int[] arr, int arrLength)
    7.         {
    8.             if (arrLength == 1)
    9.                 return;
    10.  
    11.             for (int i = 0; i < arrLength - 1; i++)
    12.             {
    13.                 if (arr[i] > arr[i + 1])
    14.                 {
    15.                     //交换arr[i]和arr[i+1]的值
    16.                     int temp = arr[i];
    17.                     arr[i] = arr[i + 1];
    18.                     arr[i + 1] = temp;
    19.                 }
    20.             }
    21.  
    22.             RecursiveBubbleSort(arr, arrLength - 1);
    23.         }
    24.  
    25.         public static void RecursiveBubbleSortRun()
    26.         {
    27.             int[] arr = { 1, 8, 9, 5, 6, 2, 3, 4, 7 };
    28.             int arrLength = arr.Length;
    29.             RecursiveBubbleSort(arr, arrLength);
    30.             Console.WriteLine("排序后结果：" + string.Join(", ", arr));
    31.         }

    C#选择排序算法

    简介

    选择排序算法的基本思想是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

    详细文章描述

    https://mp.weixin.qq.com/s/B1QdqyP8HQgOv8tlSujtog

    代码实现

    1.         /// <summary>
    2.         /// 选择排序算法
    3.         /// </summary>
    4.         public static void SelectionSortAlgorithmMain()
    5.         {
    6.             int[] array = { 64, 25, 12, 22, 11, 99, 3, 100 };
    7.  
    8.             Console.WriteLine("原始数组: ");
    9.             PrintArray(array);
    10.  
    11.             SelectionSortAlgorithm(array);
    12.  
    13.             Console.WriteLine("排序后的数组: ");
    14.             PrintArray(array);
    15.         }
    16.  
    17.         static void SelectionSortAlgorithm(int[] arr)
    18.         {
    19.             int n = arr.Length;
    20.  
    21.             for (int i = 0; i < n - 1; i++)
    22.             {
    23.                 // 在未排序部分中找到最小元素的索引
    24.                 int minIndex = i;
    25.                 for (int j = i + 1; j < n; j++)
    26.                 {
    27.                     if (arr[j] < arr[minIndex])
    28.                     {
    29.                         minIndex = j;
    30.                     }
    31.                 }
    32.  
    33.                 // 将最小元素与未排序部分的第一个元素交换位置
    34.                 int temp = arr[minIndex];
    35.                 arr[minIndex] = arr[i];
    36.                 arr[i] = temp;
    37.             }
    38.         }
    39.  
    40.         static void PrintArray(int[] arr)
    41.         {
    42.             int n = arr.Length;
    43.             for (int i = 0; i < n; ++i)
    44.             {
    45.                 Console.Write(arr[i] + " ");
    46.             }
    47.             Console.WriteLine();
    48.         }

    C#插入排序算法

    简介

    插入排序算法是一种简单、直观的排序算法，其原理是将一个待排序的元素逐个地插入到已经排好序的部分中。

    详细文章描述

    https://mp.weixin.qq.com/s/YEregZ_GOGgEltGUJadycw

    代码实现

    1.  public static void InsertionSort(int[] array)
    2.         {
    3.             int arrayLength = array.Length;//数组长度（时间复杂度为O(n^2)）
    4.             for (int i = 1; i < arrayLength; ++i)
    5.             {
    6.                 //定义临时变量
    7.                 int temp = array[i];
    8.                 int j = i - 1;
    9.  
    10.                 while (j >= 0 && array[j] > temp)
    11.                 {
    12.                     array[j + 1] = array[j];
    13.                     j--;
    14.                 }
    15.  
    16.                 array[j + 1] = temp;
    17.             }
    18.         }
    19.  
    20.         public static void InsertionSortRun()
    21.         {
    22.             int[] array = { 26, 15, 5, 3, 38, 36, 44, 27, 47, 2, 46, 4, 50, 19, 48 };
    23.  
    24.             Console.WriteLine("排序前:" + string.Join(", ", array));
    25.  
    26.             InsertionSort(array);
    27.  
    28.             Console.WriteLine("排序后:" + string.Join(", ", array));
    29.         }

    C#希尔排序算法

    简介

    希尔排序简单的来说就是一种改进的插入排序算法，它通过将待排序的元素分成若干个子序列，然后对每个子序列进行插入排序，最终逐步缩小子序列的间隔，直到整个序列变得有序。希尔排序的主要思想是通过插入排序的优势，减小逆序对的距离，从而提高排序效率。

    详细文章描述

    https://mp.weixin.qq.com/s/_t9QVuj_rLcNomyv7LcGMA

    代码实现

    1. public static void ShellSort(int[] array)
    2.         {
    3.             int arrLength = array.Length;
    4.  
    5.             // 初始化增量（初始间隔）为数组长度的一半
    6.             int gap = arrLength / 2;
    7.  
    8.             // 不断缩小增量，直到增量为1
    9.             while (gap > 0)
    10.             {
    11.                 // 对每个子序列进行插入排序
    12.                 for (int i = gap; i < arrLength; i++)
    13.                 {
    14.                     int temp = array[i];
    15.                     int j = i;
    16.  
    17.                     // 在子序列内部进行插入排序
    18.                     while (j >= gap && array[j - gap] > temp)
    19.                     {
    20.                         array[j] = array[j - gap];
    21.                         j -= gap;
    22.                     }
    23.  
    24.                     array[j] = temp;
    25.                 }
    26.  
    27.                 // 缩小增量
    28.                 gap /= 2;
    29.             }
    30.         }
    31.  
    32.         public static void ShellSortRun()
    33.         {
    34.             int[] array = { 19, 20, 22, 32, 34, 50, 99, 49, 1, 11, 11, 55, 35, 93, 96, 71, 70, 38, 78, 48 };
    35.  
    36.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    37.  
    38.             ShellSort(array);
    39.  
    40.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    41.         }

    C#归并排序算法

    简介

    归并排序是一种常见的排序算法，它采用分治法的思想，在排序过程中不断将待排序序列分割成更小的子序列，直到每个子序列中只剩下一个元素，然后将这些子序列两两合并排序，最终得到一个有序的序列。

    详细文章描述

    https://mp.weixin.qq.com/s/ToURWBfVIl7087Ago8fGdQ

    代码实现

    1.   public static void MergeSort(int[] arr, int left, int right)
    2.         {
    3.             if (left < right)
    4.             {
    5.                 // 计算中间索引
    6.                 int mid = (left + right) / 2;
    7.  
    8.                 // 对左半部分数组进行归并排序
    9.                 MergeSort(arr, left, mid);
    10.  
    11.                 // 对右半部分数组进行归并排序
    12.                 MergeSort(arr, mid + 1, right);
    13.  
    14.                 // 合并两个有序数组
    15.                 Merge(arr, left, mid, right);
    16.             }
    17.         }
    18.  
    19.         public static void Merge(int[] arr, int left, int mid, int right)
    20.         {
    21.             int n1 = mid - left + 1; // 左半部分数组的长度
    22.             int n2 = right - mid;    // 右半部分数组的长度
    23.  
    24.             // 创建临时数组
    25.             int[] leftArr = new int[n1];
    26.             int[] rightArr = new int[n2];
    27.  
    28.             // 将数据拷贝到临时数组
    29.             for (int i = 0; i < n1; ++i)
    30.             {
    31.                 leftArr[i] = arr[left + i];
    32.             }
    33.  
    34.             for (int j = 0; j < n2; ++j)
    35.             {
    36.                 rightArr[j] = arr[mid + 1 + j];
    37.             }
    38.  
    39.             // 合并两个有序数组
    40.             int k = left;   // 初始化合并后的数组索引
    41.             int p = 0;      // 初始化左半部分数组的索引
    42.             int q = 0;      // 初始化右半部分数组的索引
    43.  
    44.             while (p < n1 && q < n2)
    45.             {
    46.                 if (leftArr[p] <= rightArr[q])
    47.                 {
    48.                     arr[k] = leftArr[p];
    49.                     p++;
    50.                 }
    51.                 else
    52.                 {
    53.                     arr[k] = rightArr[q];
    54.                     q++;
    55.                 }
    56.                 k++;
    57.             }
    58.  
    59.             // 复制左半部分数组的剩余元素
    60.             while (p < n1)
    61.             {
    62.                 arr[k] = leftArr[p];
    63.                 p++;
    64.                 k++;
    65.             }
    66.  
    67.             // 复制右半部分数组的剩余元素
    68.             while (q < n2)
    69.             {
    70.                 arr[k] = rightArr[q];
    71.                 q++;
    72.                 k++;
    73.             }
    74.         }
    75.  
    76.         public static void MergeSortRun()
    77.         {
    78.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3 };
    79.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    80.  
    81.             MergeSort(array, 0, array.Length - 1);
    82.  
    83.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    84.         }   

    C#快速排序算法

    简介

    快速排序是一种常用的排序算法，它基于分治的思想，通过将一个无序的序列分割成两个子序列，并递归地对子序列进行排序，最终完成整个序列的排序。

    详细文章描述

    https://mp.weixin.qq.com/s/7vms2Q4s7DBdFs31w4cfVA

    代码实现

    1.  public class 快速排序算法
    2.     {
    3.         public static void Sort(int[] array, int low, int high)
    4.         {
    5.             if (low < high)
    6.             {
    7.                 //将数组分割为两部分，并返回分割点的索引
    8.                 int pivotIndex = Partition(array, low, high);
    9.  
    10.                 //递归对分割后的两部分进行排序
    11.                 Sort(array, low, pivotIndex - 1);
    12.                 Sort(array, pivotIndex + 1, high);
    13.             }
    14.         }
    15.  
    16.         private static int Partition(int[] array, int low, int high)
    17.         {
    18.             //选择最后一个元素作为基准元素
    19.             int pivot = array[high];
    20.             int i = low - 1;
    21.  
    22.             for (int j = low; j <= high - 1; j++)
    23.             {
    24.                 //如果当前元素小于等于基准元素，则将它与i+1位置的元素交换
    25.                 if (array[j] <= pivot)
    26.                 {
    27.                     i++;
    28.                     Swap(array, i, j);
    29.                 }
    30.             }
    31.  
    32.             //将基准元素放置到正确的位置上
    33.             Swap(array, i + 1, high);
    34.  
    35.             return i + 1; //返回基准元素的索引
    36.         }
    37.  
    38.         private static void Swap(int[] array, int i, int j)
    39.         {
    40.             int temp = array[i];
    41.             array[i] = array[j];
    42.             array[j] = temp;
    43.         }
    44.  
    45.         public static void QuickSortRun()
    46.         {
    47.             int[] array = { 2, 3, 5, 38, 19, 15, 26, 27, 36, 44, 47, 46, 50, 48, 4 };
    48.             Sort(array, 0, array.Length - 1);
    49.             Console.WriteLine("排序后结果：" + string.Join(", ", array));
    50.         }
    51.     }

    C#堆排序算法

    简介

    堆排序是一种高效的排序算法，基于二叉堆数据结构实现。它具有稳定性、时间复杂度为O(nlogn)和空间复杂度为O(1)的特点。

    详细文章描述

    https://mp.weixin.qq.com/s/zS_ESKzlg05ICqFPIaePkg

    代码实现

    1.  public static void HeapSort(int[] array)
    2.         {
    3.             int arrayLength = array.Length;
    4.  
    5.             //构建最大堆
    6.             for (int i = arrayLength / 2 - 1; i >= 0; i--)
    7.                 Heapify(array, arrayLength, i);
    8.  
    9.             //依次取出堆顶元素，并重新调整堆
    10.             for (int i = arrayLength - 1; i >= 0; i--)
    11.             {
    12.                 //将堆顶元素与当前最后一个元素交换
    13.                 int temp = array[0];
    14.                 array[0] = array[i];
    15.                 array[i] = temp;
    16.  
    17.                 //重新调整堆
    18.                 Heapify(array, i, 0);
    19.             }
    20.         }
    21.  
    22.         private static void Heapify(int[] arr, int n, int i)
    23.         {
    24.             int largest = i; //假设父节点最大
    25.             int left = 2 * i + 1; //左子节点
    26.             int right = 2 * i + 2; //右子节点
    27.  
    28.             //如果左子节点大于父节点，则更新最大值
    29.             if (left < n && arr[left] > arr[largest])
    30.                 largest = left;
    31.  
    32.             //如果右子节点大于父节点和左子节点，则更新最大值
    33.             if (right < n && arr[right] > arr[largest])
    34.                 largest = right;
    35.  
    36.             //如果最大值不是当前父节点，则交换父节点和最大值，并继续向下调整堆
    37.             if (largest != i)
    38.             {
    39.                 int swap = arr[i];
    40.                 arr[i] = arr[largest];
    41.                 arr[largest] = swap;
    42.  
    43.                 Heapify(arr, n, largest);
    44.             }
    45.         }
    46.  
    47.         public static void HeapSortRun()
    48.         {
    49.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888, 0, -1 };
    50.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    51.  
    52.             HeapSort(array);
    53.  
    54.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    55.         }

    C#计数排序算法

    简介

    计数排序是一种非比较性的排序算法，适用于排序一定范围内的整数。它的基本思想是通过统计每个元素的出现次数，然后根据元素的大小依次输出排序结果。

    详细文章描述

    https://mp.weixin.qq.com/s/PA5NNqcy3CM9PSncWCsmEg

    代码实现

    1. public static void CountingSort(int[] array)
    2.         {
    3.             int arrayLength = array.Length;
    4.             if (arrayLength <= 1) return;
    5.  
    6.             int min = array[0];
    7.             int max = array[0];
    8.  
    9.             //找出最大值和最小值
    10.             for (int i = 1; i < arrayLength; i++)
    11.             {
    12.                 if (array[i] < min) min = array[i];
    13.                 if (array[i] > max) max = array[i];
    14.             }
    15.  
    16.             //统计每个元素出现的次数
    17.             int[] count = new int[max - min + 1];
    18.  
    19.             //统计每个元素出现的次数
    20.             for (int i = 0; i < arrayLength; i++)
    21.             {
    22.                 count[array[i] - min]++;
    23.             }
    24.  
    25.             //根据count数组和min值确定每个元素的起始位置
    26.             for (int i = 1; i < count.Length; i++)
    27.             {
    28.                 count[i] += count[i - 1];
    29.             }
    30.  
    31.             //存储排序结果
    32.             int[] temp = new int[arrayLength];
    33.  
    34.             //根据count数组和min值确定每个元素在temp数组中的位置
    35.             for (int i = arrayLength - 1; i >= 0; i--)
    36.             {
    37.                 int index = count[array[i] - min] - 1;
    38.                 temp[index] = array[i];
    39.                 count[array[i] - min]--;
    40.             }
    41.  
    42.             //将排序结果复制回原数组
    43.             for (int i = 0; i < arrayLength; i++)
    44.             {
    45.                 array[i] = temp[i];
    46.             }
    47.         }
    48.  
    49.         public static void CountingSortRun()
    50.         {
    51.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888};
    52.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    53.  
    54.             CountingSort(array);
    55.  
    56.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    57.         }

    C#桶排序算法

    简介

    桶排序是一种线性时间复杂度的排序算法，它将待排序的数据分到有限数量的桶中，每个桶再进行单独排序，最后将所有桶中的数据按顺序依次取出，即可得到排序结果。

    详细文章描述

    https://mp.weixin.qq.com/s/YzviDcm3-4E5Wf2jooylJQ

    代码实现

    1. public static void BucketSort(int[] array)
    2.         {
    3.             int arrLength = array.Length;
    4.             if (arrLength <= 1)
    5.             {
    6.                 return;
    7.             }
    8.  
    9.             //确定桶的数量
    10.             int maxValue = array[0], minValue = array[0];
    11.             for (int i = 1; i < arrLength; i++)
    12.             {
    13.                 if (array[i] > maxValue)
    14.                     maxValue = array[i];
    15.                 if (array[i] < minValue)
    16.                     minValue = array[i];
    17.             }
    18.             int bucketCount = (maxValue - minValue) / arrLength + 1;
    19.  
    20.             //创建桶并将数据放入桶中
    21.             List<List<int>> buckets = new List>(bucketCount);
    22.             for (int i = 0; i < bucketCount; i++)
    23.             {
    24.                 buckets.Add(new List<int>());
    25.             }
    26.  
    27.             for (int i = 0; i < arrLength; i++)
    28.             {
    29.                 int bucketIndex = (array[i] - minValue) / arrLength;
    30.                 buckets[bucketIndex].Add(array[i]);
    31.             }
    32.  
    33.             //对每个非空的桶进行排序
    34.             int index = 0;
    35.             for (int i = 0; i < bucketCount; i++)
    36.             {
    37.                 if (buckets[i].Count == 0)
    38.                 {
    39.                     continue;
    40.                 }
    41.  
    42.                 int[] tempArr = buckets[i].ToArray();
    43.                 Array.Sort(tempArr);
    44.  
    45.                 foreach (int num in tempArr)
    46.                 {
    47.                     array[index++] = num;
    48.                 }
    49.             }
    50.         }
    51.  
    52.         public static void BucketSortRun()
    53.         {
    54.             int[] array = { 19, 27, 46, 48, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3, 99, 888};
    55.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    56.  
    57.             BucketSort(array);
    58.  
    59.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    60.         }

    C#基数排序算法

    简介

    基数排序是一种非比较性排序算法，它通过将待排序的数据拆分成多个数字位进行排序。

    详细文章描述

    https://mp.weixin.qq.com/s/dCG-LLim4UGD1kIY2a3hmA

    代码实现

    1. public static void RadixSort(int[] array)
    2.         {
    3.             if (array == null || array.Length < 2)
    4.             {
    5.                 return;
    6.             }
    7.  
    8.             //获取数组中的最大值，确定排序的位数
    9.             int max = GetMaxValue(array);
    10.  
    11.             //进行基数排序
    12.             for (int exp = 1; max / exp > 0; exp *= 10)
    13.             {
    14.                 CountingSort(array, exp);
    15.             }
    16.         }
    17.  
    18.         private static void CountingSort(int[] array, int exp)
    19.         {
    20.             int arrayLength = array.Length;
    21.             int[] output = new int[arrayLength];
    22.             int[] count = new int[10];
    23.  
    24.             //统计每个桶中的元素个数
    25.             for (int i = 0; i < arrayLength; i++)
    26.             {
    27.                 count[(array[i] / exp) % 10]++;
    28.             }
    29.  
    30.             //计算每个桶中最后一个元素的位置
    31.             for (int i = 1; i < 10; i++)
    32.             {
    33.                 count[i] += count[i - 1];
    34.             }
    35.  
    36.             //从原数组中取出元素，放入到输出数组中
    37.             for (int i = arrayLength - 1; i >= 0; i--)
    38.             {
    39.                 output[count[(array[i] / exp) % 10] - 1] = array[i];
    40.                 count[(array[i] / exp) % 10]--;
    41.             }
    42.  
    43.             //将输出数组复制回原数组
    44.             for (int i = 0; i < arrayLength; i++)
    45.             {
    46.                 array[i] = output[i];
    47.             }
    48.         }
    49.  
    50.         private static int GetMaxValue(int[] arr)
    51.         {
    52.             int max = arr[0];
    53.             for (int i = 1; i < arr.Length; i++)
    54.             {
    55.                 if (arr[i] > max)
    56.                 {
    57.                     max = arr[i];
    58.                 }
    59.             }
    60.             return max;
    61.         }
    62.  
    63.         public static void RadixSortRun()
    64.         {
    65.             int[] array = { 19, 27, 46, 48, 99, 888, 50, 2, 4, 44, 47, 36, 38, 15, 26, 5, 3 };
    66.  
    67.             Console.WriteLine("排序前数组：" + string.Join(", ", array));
    68.  
    69.             RadixSort(array);
    70.  
    71.             Console.WriteLine("排序后数组：" + string.Join(", ", array));
    72.         }
  • 相关阅读:
    多线程拷贝文件
    Maven中的小学问（版本问题、打包问题等）
    MySQL - limit 分页查询 （查询操作 五）
    设置meta description 为什么显示显示本网站使用第三方cookie和相关技术
    经典案例｜使用Supabase解决可视化大屏项目的常见问题
    怎么制作精美的公众号文章？教你几招
    优思学院｜精益管理涵盖哪些内容？
    微信小程序获取用户头像和昵称能力调整！新的代替方案！
    枚举算法的二分法
    如何使用Spring Security控制会话
  • 原文地址：https://blog.csdn.net/qq_37237487/article/details/133958330