算法-2.内排序

2. 内排序

2.1 三种代价为 Θ(n2) 排序算法

2.1.1 插入排序

※最佳时间代价 Θ(n)，平均、最差时间代价均为 Θ(n2)

template<class Elem>

void swap(Elem A[],int a,int b){

    int temp;

    temp=A[a];

    A[a]=A[b];

    A[b]=temp;

}

 

template<class Elem>

void insort(Elem A[],int n){

    for(int i=0;i<n;i++)

        for(int j=i;(j>0&&A[j]<A[j-1]);j--)

            swap(A,j,j-1);

}

2.1.2 起泡排序

※最佳、平均、最差执行时间均为 Θ(n2)

template<class Elem>

void bubsort(Elem A[],int n){

    for(int i=0;i<n;i++)

        for(int j=n-1;j>0;j--)

            if(A[j]<A[j-1])

                swap(A,j,j-1);

}

2.1.3 选择排序

※最佳、平均、最差执行时间均为 Θ(n2)

template<class Elem>

void selsort(Elem A[],int n){

    for(int i=0;i<n;i++){

        int lowindex=i;

        for(int j=i;j<n;j++)

            if(A[j]<A[lowindex])

                lowindex=j;

        swap(A,i,lowindex);

    }

}

   

2.2 Shell排序

※平均时间代价 Θ(n1.5)

template<class Elem>

void inssort2(Elem A[],int n,int incr){

    for(int i=incr;i<n;i+=incr)

        for(int j=i;(j>=incr&&(A[j]<A[j-incr]));j-=incr)

            swap(A,j,j-incr);

}

 

template<class Elem>

void shellsort(Elem A[],int n){

    for(int i=n/2;i>2;i/=2)

        for(int j=0;j<i;j++)

            inssort2(&A[j],n-j,i);

    inssort2(A,n,1);

}

2.3 快速排序

※平均、最优时间代价 Θ(nlogn)，最差时间代价 Θ(n2)

template<class Elem>
int findpivot(Elem A[],int i,int j){
    return (i+j)/2;
}

template<class Elem>
int partition(Elem A[],int l,int r,Elem &pivot){
    do{
        while(A[++l]<pivot);
        while((r!=0)&&(A[--r]>pivot));
        swap(A,l,r);
    }while(l<r);
    swap(A,l,r);
    return l;
}

template<class Elem>
void qsort(Elem A[],int i,int j){
    if(j<=i) return;
    int pivotindex=findpivot(A,i,j);
    swap(A,pivotindex,j);
    int k=partition(A,i-1,j,A[j]);
    swap(A,k,j);
    qsort(A,i,k-1);
    qsort(A,k+1,j);
}

2.4 归并排序

※最佳、平均、最差时间代价均为 Θ(nlogn)

template<class Elem>

void insort(Elem A[],int n){

    for(int i=0;i<n;i++)

        for(int j=i;(j>0&&A[j]<A[j-1]);j--)

            swap(A,j,j-1);

}

 

template<class Elem>

void mergesort(Elem A[],Elem temp[],int left,int right){

    if((right-left)<=3){

        insort<Elem>(&A[left],right-left+1);

        return ;

    }

  

    int i,j,k,mid=(left+right)/2;

    if(left==right)

        return ;

    mergesort<Elem>(A,temp,left,mid);

    mergesort<Elem>(A,temp,mid+1,right);

    for(i=mid;i>=left;i--)

        temp[i]=A[i];

    for(j=right;j>=right-mid;j--)

        temp[j]=A[mid+right-j+1];

    for(i=left,j=right,k=left;k<=right;k++)

        if(temp[i]<temp[j])

            A[k]=temp[i++];

        else

            A[k]=temp[j--];          

}

2.5 堆排序

※最佳、平均、最差时间代价均为 Θ(nlogn)