ToB企服应用市场:ToB评测及商务社交产业平台

标题: 【唐叔学算法】第19天：互换排序-冒泡排序与快速排序的深度剖析及Java实现 [打印本页]

---

作者: 嚴華    时间: 昨天 12:54
标题: 【唐叔学算法】第19天：互换排序-冒泡排序与快速排序的深度剖析及Java实现
弁言

排序算法是计算机科学中的基础问题，而互换排序作为其中一类经典的排序方法，因其简朴直观的思想和易于实现的特点，在初学者中广受欢迎。互换排序的核心思想是通过不断互换相邻元向来达到排序的目的。本文将深入探讨两种典型的互换排序算法：冒泡排序和快速排序，分析它们的原理、实现细节、时间复杂度和空间复杂度，并通过Java代码进行详细实现。
冒泡排序：简朴却经典的排序算法

算法原理

冒泡排序（Bubble Sort）是一种基础的互换排序算法，其核心思想是通过重复地遍历待排序的序列，依次比较相邻的两个元素，如果它们的顺序错误就互换它们的位置。这样，每一轮遍历都会将当前未排序部分的最大（或最小）元素“冒泡”到序列的末了。
算法步骤

• 从序列的起始位置开始，比较相邻的两个元素。
  
• 如果前一个元素大于后一个元素，则互换它们的位置。
  
• 对序列中的每一对相邻元素重复上述操纵，直到序列末了。
  
• 重复以上步骤，直到没有需要互换的元素为止。
  

时间复杂度与空间复杂度

• 时间复杂度：
  
  
  
  • 最坏情况：O(n²)，当输入序列是逆序时，需要进行n(n-1)/2次比较和互换。
    
  • 最好情况：O(n)，当输入序列已经有序时，只需进行一次遍历即可。
    
  • 平均情况：O(n²)。
    
  
  
• 空间复杂度：O(1)，冒泡排序是原地排序算法，不需要额外的存储空间。
  

Java实现

1. public class BubbleSort {
2.     public static void bubbleSort(int[] arr) {
3.         int n = arr.length;
4.         for (int i = 0; i < n - 1; i++) {
5.             boolean swapped = false; // 优化：如果某一轮没有交换，说明已经有序
6.             for (int j = 0; j < n - 1 - i; j++) {
7.                 if (arr[j] > arr[j + 1]) {
8.                     // 交换
9.                     int temp = arr[j];
10.                     arr[j] = arr[j + 1];
11.                     arr[j + 1] = temp;
12.                     swapped = true;
13.                 }
14.             }
15.             if (!swapped) {
16.                 break; // 如果没有交换，提前退出
17.             }
18.         }
19.     }
21.     public static void main(String[] args) {
22.         int[] arr = {64, 34, 25, 12, 22, 11, 90};
23.         bubbleSort(arr);
24.         System.out.println("Sorted array: ");
25.         for (int i : arr) {
26.             System.out.print(i + " ");
27.         }
28.     }
29. }

复制代码

快速排序：高效的分治排序算法

算法原理

快速排序（Quick Sort）是一种基于分治思想的互换排序算法。其核心思想是选择一个“基准元素”（pivot），将序列分为两部分：一部分比基准元素小，另一部分比基准元素大，然后递归地对这两部分进行排序。
算法步骤

• 选择一个基准元素（通常选择第一个元素、末了一个元素或中间元素）。
  
• 将序列分为两部分：小于基准元素的部分和大于基准元素的部分。
  
• 对这两部分分别递归地进行快速排序。
  
• 合并效果。
  

时间复杂度与空间复杂度

• 时间复杂度：
  
  
  
  • 最坏情况：O(n²)，当每次选择的基准元素都是序列的最大或最小值时，快速排序会退化为冒泡排序。
    
  • 最好情况：O(n log n)，当每次选择的基准元素都能将序列均匀地分为两部分时。
    
  • 平均情况：O(n log n)。
    
  
  
• 空间复杂度：O(log n)，快速排序的空间复杂度主要取决于递归调用的栈空间。
  

Java实现

1. public class QuickSort {
2.     public static void quickSort(int[] arr, int low, int high) {
3.         if (low < high) {
4.             int pivotIndex = partition(arr, low, high); // 获取基准元素的位置
5.             quickSort(arr, low, pivotIndex - 1); // 递归排序左子序列
6.             quickSort(arr, pivotIndex + 1, high); // 递归排序右子序列
7.         }
8.     }
10.     private static int partition(int[] arr, int low, int high) {
11.         int pivot = arr[high]; // 选择最后一个元素作为基准
12.         int i = low - 1; // i指向小于基准的元素的位置
14.         for (int j = low; j < high; j++) {
15.             if (arr[j] < pivot) {
16.                 i++;
17.                 // 交换
18.                 int temp = arr[i];
19.                 arr[i] = arr[j];
20.                 arr[j] = temp;
21.             }
22.         }
24.         // 将基准元素放到正确的位置
25.         int temp = arr[i + 1];
26.         arr[i + 1] = arr[high];
27.         arr[high] = temp;
29.         return i + 1; // 返回基准元素的位置
30.     }
32.     public static void main(String[] args) {
33.         int[] arr = {10, 7, 8, 9, 1, 5};
34.         quickSort(arr, 0, arr.length - 1);
35.         System.out.println("Sorted array: ");
36.         for (int i : arr) {
37.             System.out.print(i + " ");
38.         }
39.     }
40. }

复制代码

对比与总结

冒泡排序 vs 快速排序

特性冒泡排序快速排序时间复杂度O(n²)平均 O(n log n)，最坏 O(n²)空间复杂度O(1)O(log n)稳定性稳定不稳定适用场景小规模数据或基本有序数据大规模数据或随机数据 选择与应用

• 冒泡排序：虽然时间复杂度较高，但实现简朴，适合教学和小规模数据的排序。
  
• 快速排序：虽然实现稍复杂，但时间复杂度较低，适合处理大规模数据，是实际应用中最常用的排序算法之一。
  

通过本文的解说和Java实现，希望读者能够深入明白冒泡排序和快速排序的原理和实现细节，并在实际编程中根据需求灵活选择合适的排序算法。

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

---

欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/)

Powered by Discuz! X3.4