数据结构 -- 交换排序（冒泡排序和快速排序）

冒泡排序

基于“交换”的排序：根据序列中两个元素关键字的比较效果来对换这两个记录在序列中的位置

1. //交换
2. void swap(int &a,int &b){
3.     int temp = a;
4.     a = b;
5.     b = temp;
6. }
8. //冒泡排序
9. void BubbleSort(int A[],int n){
10.     for(int i=0;i<n-1;i++){
11.         bool flag = false;                        //表示本趟冒泡是否发生交换的标志
12.         for(int j = n-1;j>i;j--)
13.             if(A[j-1]>A[j]){
14.                 swap(A[j-1],A[j]);
15.                 flag = true;
16.             }
17.         if(flag == false)        return ;                //本趟遍历后没有发生交换，说明表已经有序
18.     }
19. }

复制代码

算法性能分析

是否适用于链表？

适用，可从前今后“冒泡”，每⼀趟将更⼤的元素“冒”到链尾

快速排序

算法思想

<img alt="image-20250513113311757" />

1. //用第一个元素将待排序元素划分为左右两个部分
2. int Partition(int A[],int low,int high){
3.     int pivot = A[low];
4.     while(low<high){
5.         while(low<high&&A[high]>=pivot)        --high;
6.         A[low] = A[high];
7.         while(low<high&&A[low]<=pivot)        ++low;
8.         A[high] = A[low];
9.     }
10.     A[low] = pivot;
11.     return low;
12. }
14. //快速排序
15. void QuickSort(int A[],int low,int high){
16.     if(low<high){
17.         int pivotpos = Partition(A,low,high);
18.         QuickSort(A,low,pivotpos);
19.         QuickSort(A,pivotpos,high);
20.     }
21. }

复制代码

算法效率分析

时间复杂度=O(n*递归层数)
空间复杂度=O(递归层数)

时间复杂度空间复杂度最好O(nlog2n)O(log2n)最坏O(n2)O(n)若每⼀次选中的“枢轴”将待排序序列划分为很不匀称的两个部门，则会导致递归深度增加，算法效率变低
若初始序列有序或逆序，则快速排序的性能最差（因为每次选择的都是最靠边的元素）
若每⼀次选中的“枢轴”将待排序序列划分为匀称的两个部门，则递归深度最⼩，算法效率最⾼
快速排序算法优化思路：只管选择可以把数据中分的枢轴元素。
eg：①选头、中、尾三个位置的元素，取中心值作为枢轴元素；②随机选⼀个元素作为枢轴元素

注：408原题中说，对所有尚未确定最终位置的所有元素进行⼀遍处理惩罚称为“⼀趟”排序，因此⼀次“划分”≠⼀趟排序。
⼀次划分可以确定⼀个元素的最终位置，而⼀趟排序大概可以确定多个元素的最终位置。