插入排序:逐个处理待排序的记录。每个新纪录与前面已排序的子序列进行比较,将它插入到子序列中正确的位置。
template <typename E, typename Comp>
void inssort(E A[], int n) { // Insertion Sort
for (int i=1; i<n; i++) // Insert i'th recor
for (int j=i; (j>0) && (Comp::prior(A[j], A[j-1])); j--)
swap(A, j, j-1);}
冒泡排序:包括一个简单的双重for循环。第一次的内部for循环从记录数组的底部比较到顶部,比较相邻的关键码。如果低序号的关键码值比高序号的关键码值大,则将二者交换顺序。一旦遇到一个最小关键码值,这个过程将是他像气泡一样被推到数组的顶部,第二次再重复上面的过程。但是,既然知道最小元素被排到了数组的最前面,没有必要在比较最上面的两个元素了。同样,每一轮循环都是比较相邻的关键码,但是都将比上一轮循环少比较一个关键码。
template <typename E, typename Comp>
void bubsort(E A[], int n) { // Bubble Sort
for (int i=0; i<n-1; i++) // Bubble up i'th record
for (int j=n-1; j>i; j--)
if (Comp::prior(A[j], A[j-1]))
swap(A, j, j-1);}
选择排序:选择排序的第i次是选择数组中第i小的记录,并将该记录放到数组的第i个位置。
template<class elem,class comp>
void selsort(elem A[],int n){
for(int i=0;i<n-1;i++){
int lowindex=i;
for(int j=n-1;j>i;j--)
if(comp::lt(A[j],A[lowindex]))
lowindex=j;
swap(A,i,lowindex);
}}
shell排序:使用分组并排序的,将序列分成子序列,然后分别对子序列进行排序,最后将子序列组合起来。将数组元素分成虚拟子序列,每个子序列用插入排序方法进行排序。
template<class elem,class comp>
void inssort2(elem A[],int n,int incr){
for (int i=incr;i<n;i+=incr)
for(int j>=i;(j>=incr)&&( comp:: lt (A[ j ],A[ j -incr ])); j-=incr)
swap( A, j ,j-incr);
}
template<class elem,class comp>
void shellsort(elem A[],int n){
for(int i=n/2;i>2;i/=2){
for(int j=0;j<i;j++)
inssort2< elem ,comp>( &A[ j ],n-j; i);
inssort2< elem ,comp>( A , n ; 1 ); }
快速排序:首先选择一个轴值,假设输入的数组中有k个小于轴值的结点,于是这些节点被放在数组最左边的k个位置上,而大于轴值的结点被放在数组最右边的n-k个位置上。在给定分割中的值不必排序,只要求所有节点都放在了正确的位置上,而轴值的位置就是下标k。快速排序再对轴值的左右子数组分别进行类似的操作,其中一个数组有k个元素,另一个数组有n-k-1个元素。
template<class elem,class comp>
void qsort(elem A[],int i,int j){
// Simple findpivot: Pick middle value in array
template <typename E>
inline int findpivot(E A[], int i, int j)
{ return (i+j)/2; }
// Partition the array
template <typename E, typename Comp>
inline int partition(E A[], int l, int r, E& pivot) {
do { // Move the bounds inward until they meet
while (Comp::prior(A[++l], pivot)); // Move l right and
while ((l < r) && Comp::prior(pivot, A[--r])); // r left
swap(A, l, r); // Swap out-of-place values
} while (l < r); // Stop when they cross
return l; // Return first position in right partition
}
// qsort core function: Basic qsort
template <typename E, typename Comp>
void qsort(E A[], int i, int j) { // Quicksort
if (j <= i) return; // Don't sort 0 or 1 element
int pivotindex = findpivot(A, i, j);
swap(A, pivotindex, j); // Put pivot at end
// k will be the first position in the right subarray
int k = partition<E,Comp>(A, i-1, j, A[j]);
swap(A, k, j); // Put pivot in place
qsort<E,Comp>(A, i, k-1);
qsort<E,Comp>(A, k+1, j);
}
template <typename E, typename Comp>
void mergesort(E A[], E temp[], int left, int right) {
if (left == right) return; // List of one element
int mid = (left+right)/2;
mergesort<E,Comp>(A, temp, left, mid);
mergesort<E,Comp>(A, temp, mid+1, right);
for (int i=left; i<=right; i++) // Copy subarray to temp
temp[i] = A[i];
// Do the merge operation back to A
int i1 = left; int i2 = mid + 1;
for (int curr=left; curr<=right; curr++) {
if (i1 == mid+1) // Left sublist exhausted
A[curr] = temp[i2++];
else if (i2 > right) // Right sublist exhausted
A[curr] = temp[i1++];
else if (Comp::prior(temp[i1], temp[i2]))
A[curr] = temp[i1++];
else A[curr] = temp[i2++];
}
}
堆排序:堆是一个完全二叉树(树的每一层除了最底层都是满的,并且最底层的结点从左到右填充),并且堆中存储的数据是局部有序的。基于最大值堆排序算法,将数组构造成一个满足堆定义的序列,然后将堆顶的最大元素取出,在对剩下的元素排成堆并取出堆顶数值,如此下去,直到堆为空。
template <typename E, typename Comp>
void heapsort(E A[], int n) { // Heapsort
E maxval;
heap<E,Comp> H(A, n, n); // Build the heap
for (int i=0; i<n; i++) // Now sort
maxval = H.removefirst(); // Place maxval at end
}