常用排序算法

#pragma once
#ifndef _ALGSORT_H_
#define _ALGSORT_H_
#define M 10                                                                                                       //M的取值范围为5~25最佳；
template <class T>
class AlgSort
{
public:
void BubbleSort(T a[], const int n)                                                              //冒泡排序算法；
{
for(int i=1; i<n; ++i)
for(int j=n-1; j>=i; --j)
if(a[j-1]>a[j])
{
T temp=a[j-1]; a[j-1]=a[j]; a[j]=temp;
}
}
void newBubbleSort(T a[], const int n)                                                       //冒泡的改进排序算法；
{
bool exchange;
for(int i=1; i<n; ++i)
{
exchange=false;
for(int j=n-1; j>=i; --j)
if(a[j-1]>a[j])
{
T temp=a[j-1]; a[j-1]=a[j]; a[j]=temp;
exchange=true;
}
if(exchange==false) return;
}
}
void InsertSort(T a[], const int left, const int right)                                 //直接插入排序算法；
{
T temp; int i, j;
for(i=left+1; i<=right; ++i)
if(a[i]<a[i-1])
{
temp=a[i]; j=i-1;
do
{
a[j+1]=a[j]; j--;
} while(j>=left&&temp<a[j]);
a[j+1]=temp;
}
}
void BinaryInsertSort(T a[], const int left, const int right)                      //折半插入排序算法；
{
T temp; int i, low, high, middle, k;
for(i=left+1; i<=right; ++i)
{
temp=a[i]; low=left; high=i-1;
while(low<=high)
{
middle=(low+high)/2;
if(temp<a[middle]) high=middle-1;
else low=middle+1;
}
for(k=i-1; k>=low; --k) a[k+1]=a[k];
a[low]=temp;
}
}
void ShellSort(T a[], const int left, const int right)                                   //希尔排序算法；
{
int i, j, gap=right-left+1;
T temp;
do
{
gap=gap/3+1;
for(i=left+gap; i<=right; ++i)
if(a[i]<a[i-gap])
{
temp=a[i]; j=i-gap;
do
{
a[j+gap]=a[j];
j-=gap;
} while(j>=left&&temp<a[j]);
a[j+gap]=temp;
}
} while(gap>1);
}
void QuickSort(T a[], const int left, const int right)                                 //快速排序算法；
{
if(left<right)
{
int pivotpos=Partition(a, left, right);
QuickSort(a, left, pivotpos-1);
QuickSort(a, pivotpos+1, right);
}
}
void newQISort(T a[], const int left, const int right)
{
newQuickSort(a, left, right);                                                               //先进行快速排序；
InsertSort(a, left, right);                                                                      //对基本有序的序列进行插入排序；
}
void QuickSort3(T a[], const int left, const int right)                               //三路划分快速排序算法，处理元素序列中的重复值；
{
int i, j, k, p, q;
T pivot=a[right];
if(right<=left) return;
i=left-1; j=right; p=left-1; q=right;
while(1)
{
while(a[++i]<pivot) if(i==j) break;
while(pivot<a[--j]) if(j==i) break;
if(i>=j) break;
T temp=a[i]; a[i]=a[j]; a[j]=temp;
if(a[i]==pivot)
{
p++;
T temp=a[p]; a[p]=a[i]; a[i]=temp;
}
if(pivot==a[j])
{
q--;
T temp=a[q]; a[q]=a[j]; a[j]=temp;
}
}
T temp=a[i]; a[i]=a[right]; a[right]=temp;
j--; i++;
for(k=right-1; k>=q; k--, i++)
{
T temp=a[k]; a[k]=a[i]; a[i]=temp;
}
for(k=left; k<=p; k++, j--)
{
T temp=a[k]; a[k]=a[j]; a[j]=temp;
}
QuickSort3(a, left, j);
QuickSort3(a, i, right);
}
void SelectSort(T a[], const int left, const int right)                                //直接选择排序算法；
{
for(int i=left; i<right; i++)
{
int k=i;                                                                                                      //在a[i]到a[n-1]寻找最小排序码的元素；
for(int j=i+1; j<=right; j++)
if(a[j]<a[k]) k=j;
if(k!=i)
{
T temp=a[i]; a[i]=a[k]; a[k]=temp;
}
}
}
void MergeSort(T a[], T aa[], const int left, const int right)                    //两路归并排序算法；
{
if(left>=right) return;
int mid=(left+right)/2;                                                                               //从中间划分为两个子序列；
mergeSort(a, aa, left, mid);
mergeSort(a, aa, mid+1, right);
merge(a, aa, left, mid, right);                                                                    //合并；
}
void newMergeSort(T a[], T aa[], const int left, const int right)            //改进的两路归并排序算法；
{
doSort(a, aa, left, right);
InsertSort(a, left, right);
}
private:
int Partition(T a[], const int low, const int high)
{
int pivotpos=low;
T pivot=a[low];
for(int i=low+1; i<=high; ++i)
if(a[i]<pivot)
{
pivotpos++;
if(pivotpos!=i)
{
T temp=a[pivotpos]; a[pivotpos]=a[i]; a[i]=temp;
}
}
a[low]=a[pivotpos]; a[pivotpos]=pivot;
return pivotpos;
}
private:
void newQuickSort(T a[], const int left, const int right)                   //取中间元素的快速排序算法；
{
if(right-left<=M) return;
int pivotpos=newPartition(a, left, right);
newQuickSort(a, left, pivotpos-1);
newQuickSort(a, pivotpos+1, right);
}
int newPartition(T a[], const int left, const int right)
{
int i=left, j=right-1;
if(left<right)
{
T pivot=median3(a, left, right);
for(; ;)
{
while(i<j&&a[i]<pivot) i++;
while(i<j&&pivot<a[j]) j--;
if(i<j)
{
T temp=a[i]; a[i]=a[j]; a[j]=temp;
i++; j--;
}
else break;
}
if(a[i]>pivot)
{
a[right]=a[i]; a[i]=pivot;
}
}
return i;
}
T& median3(T a[], const int left, const int right)                                 //三者取中算法；
{
int mid=(left+right)/2; int k=left;
if(a[mid]<a[k]) k=mid;
if(a[right]<a[k]) k=right;
if(k!=left)
{
T temp=a[left]; a[left]=a[k]; a[k]=temp;                                             //最小者交换到left位置；
}
if(mid!=right&&a[mid]<a[right])
{
T temp=a[mid]; a[mid]=a[right]; a[right]=temp;                             //中间值交换到right位置；
}
return a[right];
}
private:
void merge(T a[], T aa[], const int left, const int mid, const int right)  //两路归并排序算法；
{
for(int k=left; k<=right; k++)
aa[k]=a[k];
int s1=left, s2=mid+1, t=left;
while(s1<=mid&&s2<=right)
{
if(aa[s1]<=aa[s2]) a[t++]=aa[s1++];
else a[t++]=aa[s2++];
}
while(s1<=mid) a[t++]=aa[s1++];
while(s2<=right) a[t++]=aa[s2++];
}
private:
void doSort(T a[], T aa[], const int left, const int right)
{
if(left>=right) return;
if(right-left+1<M) return;
int mid=(left+right)/2;
doSort(a, aa, left, mid);
doSort(a, aa, mid+1, right);
improvedMerge(a, aa, left, mid, right);
}
void improvedMerge(T a[], T aa[], const int left, const int mid, const int right)
{
int s1=left, s2=right, t=left, k;
for(k=left; k<=mid; k++)
aa[k]=a[k];
for(k=mid+1; k<=right; k++)
aa[right+mid+1-k]=a[k];
while(t<=right)
{
if(aa[s1]<=aa[s2]) a[t++]=aa[s1++];
else a[t++]=aa[s2--];
}
}
};
#endif