第八章 排序 交换排序

交换排序

冒泡排序

• 基本思想 : 每趟不断将记录两两比较 , 并按照"前小后大"的规则交换

void BubbleSort(int r[], int n){
    for(int i=1; i<n; i++){ // 进行 n-1 趟排序
        for(int j=1; j<=n-m; j++)
            if(r[j]>r[j+1]){
                int temp=r[j];
                r[j]=r[j+1];
                r[j+1]temp;
            }
    }
}

• 冒泡算法的改进

• 依据 : 当某一趟没有进行任何元素交换时, 说明数组已经有序

void BubbleSort(int r[], int n){
    int fg=1; // 记录是否进行交换 
    for(int i=1; i<n&&fg==1; i++){ // 进行 n-1 趟排序
        fg=0;
        for(int j=1; j<=n-m; j++)
            if(r[j]>r[j+1]){
                fg=1;
                int temp=r[j];
                r[j]=r[j+1];
                r[j+1]temp;
            }
    }
}

时间复杂度最好 O(n), 最坏 O(n^2), 平均 O(n^2)
辅助空间 O(1)
是一种稳定排序

快速排序

• 快速排序 : 平均时间复杂度 O(nlogn)

void main(){
    Qsort(L, 1, length);
} 
void Qsort(Sqlist &L, int low, int high){
    if(low<high){ // 长度大于 1 
        int pivotloc = Partition(L, low, high);
        // 将 L.r[low, high] 一分为二 , pivotloc 为枢轴元素排好序的位置
        Qsort(L, low, pivotloc-1);
        Qsort(L, pivotloc+1, high+1); 
    }
}
int Partition(Sqlist &L, int low, int high){
    L.r[0]=L.r[low];
    int pivotkey=L.r[low].key;
    while(low<high){
        while(low<high && L.r[high].key>=pivotkey) high --;
        L.r[low]=L.r[high];
        while(low<high && L.r[low]<=pivotkey) low ++;
        L.r[high]=L.r[low];
    }
    L.r[low]=L.r[0];
    return low;
}

• Qsort() : O(logn) ; Partition() : O(n)

• 就平均计算时间而言 , 快速排序是我们所讨论的内部排序中最好的一个

• 快速排序不是原地排序 , 平均需要 O(logn) 的栈空间 , 最坏 O(n) 的栈空间

• 快速排序是一种不稳定的排序算法

• 不适用于对基本有序的序列排序 (是一种不自然的排序算法)