内排序算法

一.综合比较

稳定性：重复元素之间的相对次序在排序前后保持一致

排序算法	时间复杂度	稳定性
冒泡排序(bubblesort)	O(N^2)	稳定
归并排序(mergesort)	O(NlogN)	稳定
选择排序(selectsort)	O(N^2)
快速排序(quicksort)
堆排序()
希尔排序(shellsort)

 二.具体实现

1.冒泡排序

版本一：

void bubblesort(int A[],int n){
    bool sorted=false;
    while(!sorted){
        sorted=true;
        for(int i=1;i<n;i++)
        {
            if(A[i-1]>A[i])
            {
                swap(A[i-1],A[i]);
                sorted=false;
            }
        }
        n--;
    }
}

版本二(基于向量ADT接口的实现)：

template<typename T>
void Vector<T>::bubbleSort(Rank lo,Rank hi){
    while(!bubblesort(lo,hi--));
}

template<typename T>
bool Vector<T>::bubblesort(Rank lo,Rank,hi){
    bool sorted=true;
    while(++lo<hi){
        if(_elem[lo-1]>_elem[lo])
        {
            swap(_elem[lo-1],_elem[lo]);
            sorted=false;
        }      
    }
    return sorted;
}

改进：

template<typename T>
void Vector<T>::bubbleSort(Rank lo,Rank,hi){
    while(lo<(hi=bubble(lo,hi)));
}

template<typename T>
Rank Vector<T>::bubble(Rank lo,Rank hi){
    Rank last=lo;
    while(++lo<hi)
    {
        if(A[lo-1]<A[lo])
        {
            swap(A[lo-1],A[lo]);
            last=lo;
        }
    }
    return last;
}

2.归并排序 

版本1：

template <class Record>
void MergeSort(Record Array[],Record TempArray[],int left,int right)
{
	int middle;
	if(left<right)
	{
		middle=(left+right)/2;
		MergeSort(Array,TempArray,left,middle);
		MergeSort(Array,TempArray,middle,right);
		Merge(Array,TempArray,left,right,middle);
	}
}

template <class Record>
void Merge(Record Array[],Record TempArray[],int left,int right,int middle)
{
	int i,j,index1,index2;
	for(j=left;j<=right;j++)
		TempArray[j]=Array[j];
	 index1=left;
	 index2=middle;
	 i=left;
	 while(index1<middle&&index2<right)
	 {
	 	if(TempArray[index1]<=TempArray[index2])
	 		Array[i++]=TempArray[index1++];
	 	else
	 		Array[i++]=TempArray[index2++];
	 	
	 }
	 while(index1<middle)
	 	Array[i++]=TempArray[index1++];
	while(index2<right)
		Array[i++]=TempArray[index2++];
	
}

版本2(基于向量ADT接口的实现)：

template<typename T>
void Vector<T>::mergesort(Rank lo,Rank hi){
    if(hi-lo<2) return;
    int mi=(lo+hi)<<1;
    mergesort(lo,mi);
    mergesort(mi,hi);
    merge(lo,mi,hi);
}

template<typename T>
void Vector<T>::merge(Rank lo,Rank mi,Rank hi){
    T* A=_elem+lo;
    int lb=mi-lo;
    T* B=new T[lb];
    for(Rank i=0;i<lb;B[i]=A[i++])
    int lc=hi-mi;
    T* C=_elem+mi;
    for(Rank i=0,j=0,k=0;(j<lb)||(k<lc);){
        if((j<lb)&&((lc<=k)||(B[j]<=C[k])) A[i++]=B[j++];
        if((k<jc)&&((lb<=j)||(C[k]<B[j])) A[i++]=B[j++];
    }
    delete B[];
}

3.选择排序

版本1（思路：逐个找出第i个最小的记录，并将其放到第i个位置）：

template<class Record>
void selectsort(Record Array[],int n){
    int i,j,smallest;
    for(i=0;i<n-1;i++){
        smallest=i;
        for(j=i+1;j<n;j++)
            if(Array[j]<Array[smallest])
                smallest=j;
        swap(Array,i,smallest);
    }
}

版本2(基于列表ADT接口的实现)

(思路：将序列划分为无序前缀和有序后缀两部分，此外，还要求前缀不大于后缀，如此，每次只需从前缀中选出最大者，并作为最小元素转移至后缀中，即可使有序部分的范围不断扩张)

template<typename T>//列表的选择排序算法，对起始于位置p的n个元素排序
void List<T>::selectsort(ListNodePosi(T) p,int n){
    ListNodePosi(T) head=p->pred;
    ListNodePosi(T) tail=p;
    for(int i=0;i<n;i++)
    {
        tail=tail->succ;//待排序区间为(head,tail)
    }
    while(1<n)
    {
        ListNodePosi(T) max=selectMax(head->succ,n);//找出最大者
        insertB(tail,remove(max));//将其移至无序区间的末尾，作为有序区间新的首元素
        tail=tail->pred;
        n--;
    }
}

template<typename T>
ListNodePosi(T) List<T>::selectMax(ListNodePosi(T) p,int n){
    ListNodePosi(T) max=p;
    for(ListNodePosi(T) cur=p;1<n;n--)
    {
        if(!lt((cur=cur->succ)->data,max->data))
            max=cur;
    }
    return max;
}