【数据结构】第七章：排序

冒泡排序：

#include <cstdio>
#include <algorithm>
using namespace std;
int a[100001];
void BubbleSort(int a[],int n){
    int tmp,flag;
    for(int i = 0;i < n -1;i++){
        flag = 0;
        for(int j = 0;j < n - i -1 ;j++){
            if(a[j] > a[j + 1]){
                flag = 1;
                tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
        if(!flag){
            break;
        }
    }
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++){
        scanf("%d",&a[i]);
    }
    BubbleSort(a,n);
    for(int i = 0;i < n - 1;i++){
        printf("%d ",a[i]);
    }
    printf("%d",a[n - 1]);
}

插入排序：

#include <cstdio>
#include <algorithm>
using namespace std;
int a[100001];
void InsertSort(int a[],int n){
    int tmp,i;
    for(int P = 1;P < n;P++){
        tmp = a[P];
        for(i = P; i >= 1 && a[i - 1] > tmp; i--){
            a[i] = a[i - 1];
        }
        a[i] = tmp;
    }


}
int main(){
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++){
        scanf("%d",&a[i]);
    }
    InsertSort(a,n);
    for(int i = 0;i < n - 1;i++){
        printf("%d ",a[i]);
    }
    printf("%d",a[n - 1]);
}

时间复杂度下界
■定理:任意N个不同元素组成的序列平均具有N(N-1 )/4个逆序对。
■定理:任何仅以交换相邻两元素来排序的算法，其平均时间复杂度为Ω(N2)。
■这意味着:要提高算法效率，我们必须

    每次消去不止1个逆序对!

    每次交换相隔较远的两个数！

 

 

希尔排序：利用插入排序的简单，克服插入排序每次只交换相邻两个数的缺点。

 

void Shell_sort( ElementType A[]，int N )
{ 
    for ( D=N/2; D>0; D/=2 ) { /*希尔增量序列*/
        for(P=D;p<N;P++){/*插入排序*/
            Tmp = A[P] ;
            for ( i=P; i>=D && A[i-D]>Tmp; i-=D )
                A[i] = A[i-D] ;
            A[i] = Tmp;
        }
    }
}


#include <cstdio>
#include <algorithm>
using namespace std;
int a[100001];
void ShellSort(int a[],int n){
    int tmp,i;
    for(int D = n /2;D > 0;D /= 2){
        for(int P = D;P < n;P++){
            tmp = a[P];
            for(i = P; i >= D && a[i - D] > tmp; i -=D){
                a[i] = a[i - D];
            }
            a[i] = tmp;
        }

    }
}
int main(){
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++){
        scanf("%d",&a[i]);
    }
    ShellSort(a,n);
    for(int i = 0;i < n - 1;i++){
        printf("%d ",a[i]);
    }
    printf("%d",a[n - 1]);
}

最坏情况时间复杂度：θ(n²)：增量元素不互质，则小增量可能根本不起作用。如8，4，2，1

 

选择排序：

void Selection Sort ( ElementType A[] ，int N )
{ 
    for (i=0;i<N;i++) {
        MinPosition = ScanForMin( A，i, N-1) ;
        /*从A[i] 到A[N-1]中找最小元，并将其位置赋给MinPosition */
        Swap( A[i]，A [MinPosition] ) ;
        /*将未排序部分的最小元换到有序部分的最后位置*/
    }
}

时间复杂度：θ(n²)

如何快速找到最小元？最小堆！

 

堆排序：对选择排序的改进

void Heap_ Sort ( ElementType A[], int N )
{ 
    for ( i=N/2; i>=0; i-- ) /* BuildHeap */
        PercDown( A，i, N ) ;
    for ( i=N-1; i>0; i-- ) {
        Swap( &A[0]， &A[i] ) ; /* DeleteMax */
        PercDown( A，0，i ) ;
    }
}

 

归并排序：

递归算法：

void MSort( ElementType A[]，ElementType TmpA[] ，int L，int RightEnd )
{
    int Center ;
    if(L<RightEnd){
        Center=(L+RightEnd)/2;
        MSort( A，TmpA， L, Center ) ;
        MSort( A，TmpA, Center+1, RightEnd ) ;
        Merge( A, TmpA, L, Center+1, RightEnd ) ;
    }
}

时间复杂度T（n） = O(nlogn)

接口函数：

void Merge_sort( ElementType A[]，int N ){
    ElementType * TmpA;
    TmpA = malloc( N * sizeof( ElementType ) ) ;
    if(TmpA!=NULL){
        MSort( A，TmpA,0，N-1);
    }
    else Error(“空间不足”) ;
}

 

完整算法：

#include <cstdio>
#include <algorithm>
using namespace std;
int a[100001];
void Merge(int a[],int tmp[],int l,int center,int r){
    int lend = center - 1;
    int num = r - l + 1;
    int pos = l;
    while(l <= lend && center <= r){
        if(a[l] < a[center]){
            tmp[pos++] = a[l++];
        }
        else{
            tmp[pos++] = a[center++];
        }
    }
    while(l <= lend){
        tmp[pos++] = a[l++];
    }
    while(center <= r){
        tmp[pos++] = a[center++];
    }
    for(int i = r,j = 0;j < num;j++,i--){
        a[i] = tmp[i];
    }
}
void MSort(int a[],int tmp[],int l,int r){
    int center;
    if(l < r){
        center = (l + r) / 2;
        MSort(a,tmp,l,center);
        MSort(a,tmp,center + 1,r);
        Merge(a,tmp,l,center + 1,r);
    }
}
void MergeSort(int a[],int n){
    int *tmpA,i;
    tmpA = (int *)malloc(n * sizeof(int));
    if(tmpA != NULL){
        MSort(a,tmpA,0,n - 1);
    }
    else{
        printf("error!");
    }
}


int main(){
    int n;
    scanf("%d",&n);
    for(int i = 0;i < n;i++){
        scanf("%d",&a[i]);
    }
    MergeSort(a,n);
    for(int i = 0;i < n - 1;i++){
        printf("%d ",a[i]);
    }
    printf("%d",a[n - 1]);
}

 

快速排序：分而治之

void Quicksort( ElementType A[], int N )
{ 
    if( N < 2) return;
    pivot =从A[]中选一个主元;
    将S = { A[] \ pivot }分成2个独立子集:
        A1={a∈S|a≤pivot} 和
        A2={a∈S|a≥pivot};
    A[] = Quicksort (A1 ,N1)U{pivot}UQuicksort (A2,N2) ;
}

选主元
随机取pivot? rand()函数不便宜啊!
取头、中、尾的中位数
    例如8、12、3的中位数就是8
    测试一下pivot不同的取法对运行速度有多大影响?

ElementType Median3( ElementType A[]， int Left, int Right )
{
    int Center = (Left+Right)/2;
    if(A[Left]>A[Center])
        Swap( &A[ Left ]，&A[ Center ] ) ;
    if(A[Left]>A[Right])
        Swap( &A[ Left ]，&A[ Right ] ) ;
    if(A[Center]>A[Right])
        Swap( &A[ Center ]，&A[ Right ] ) ;
    /*A[Left]<=A[Center]<=A[Right]*/
    Swap( &A[ Center ]，&A[ Right-1 ] ); /*将pivot藏到右边*/
    /*只需要考虑A[ Left+1 ] . A[ Right-2 ] */
    return A[ Right-1. ]; /* 返回pivot */
}

算法实现：

void Quicksort( ElementType A[]，int Left, int Right )
{ 
    if ( Cutoff <= Right-Left ) {
        Pivot = Median3( A，Loft, Right ) ;
        i=Left;j=Right-1;
        for(;;){
            while(A[++i]<Pivot){)
            while(A[--j]>Pivot){)
            if(1<j)
                Swap( &A[i]， 6A[J] ) ;
            else break;
        }
        Swap( &A[1]， &A[ Right-1 ] ) ;
        Quicksort( A，Left，i-1 ) ;
        Quicksort( A，i+1, Right ) ;
    }
    else
        Insertion_Sort( A+Left, Right-Left+1 ) ;
}

#include<iostream>
using namespace std;

int partsort(int*arr,int left,int right)
{
    int key = arr[right];
    while(left < right)
    {
        while(left < right && arr[left] <= key)
        {
            left++;
        }
        arr[right] = arr[left];
        while(left < right && arr[right] >= key)
        {
            right--;
        }
        arr[left] = arr[right];
    }
    arr[right] = key;
    return right;
}

void QuickSort(int*arr,int left,int right)
{
    if(left >= right)
    {
        return;
    }
    int index = partsort(arr,left,right);
    QuickSort(arr,left,index - 1);
    QuickSort(arr,index + 1,right);
}

int main(){
    int n;
    cin>>n;
    int arr[n];
    for(int i=0;i<n;i++)
        cin>>arr[i];
    QuickSort(arr,0,n-1);
    for(int i=0;i<n;i++)
        cout<<arr[i]<<" ";
        return 0;
}

 

基数排序：利用桶排序的思想，次位优先原则