C#冒泡排序算法

冒泡排序实现原理

冒泡排序是一种简单的排序算法，其原理如下：

• 从待排序的数组的第一个元素开始，依次比较相邻的两个元素。
  
• 如果前面的元素大于反面的元素（升序排序），则互换这两个元素的位置，使较大的元素“冒泡”到右侧。
  
• 继承比较下一对相邻元素，重复步骤2，直到遍历到数组的倒数第二个元素。此时，最大的元素会被互换到数组的末了一个位置。
  
• 针对剩余尚未排序的元素，重复步骤1到步骤3。每次遍历过程中，最大的元素都会被放置到精确的位置上。
  
• 持续以上操作，直到所有元素都按照指定的顺序排列为止。
  

冒泡排序图解

冒泡排序实现的2种方式

双重循环方式实现冒泡排序

1. /// <summary>
2.                 /// 双重循环方式实现冒泡排序
3.                 /// </summary>
4.                 public static void BubbleSort()
5.                 {
6.                         int[] arr = { 1, 8, 9, 5, 6, 2, 3, 4, 7 };
7.                         int arrLength = arr.Length;
8.                         for (int i = 0; i < arrLength - 1; i++)
9.                         {
10.                                 for (int j = 0; j < arrLength - i - 1; j++)
11.                                 {
12.                                         if (arr[j] > arr[j + 1])
13.                                         {
14.                                                 //交换arr[j]和arr[j+1]的值
15.                                                 int temp = arr[j];
16.                                                 arr[j] = arr[j + 1];
17.                                                 arr[j + 1] = temp;
18.                                         }
19.                                 }
20.                         }
22.                         Console.WriteLine("排序后结果：" + string.Join(", ", arr));
23.                 }

复制代码

递归方式实现冒泡排序

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;
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.                         }
22.                         RecursiveBubbleSort(arr, arrLength - 1);
23.                 }
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.                 }

复制代码

总结

冒泡排序的名称泉源于元素比较过程中，较大的元素会渐渐向右“冒泡”到精确的位置上。它的时间复杂度为O(n^2)，在实际应用中实用于数据规模较小的情况。在实际应用中，我们需要根据具体情况选择合适的实现方式来平衡代码的可读性和排序效率。同时，如果对排序算法的效率要求较高，可以思量利用其他更高效的排序算法，如快速排序或归并排序。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。