09-排序1 排序 (25 分)

 

排序算法大汇总，缺少基数排序，需要自己再写一遍

#include <cstdio>
#include <stdlib.h>
#include <algorithm>
using namespace std;
const int CUTOFF = 50;

typedef int ElementType;

const int maxn = 1e6+1;

void InsertionSort( ElementType A[], int N )
{
    int P, i;
    ElementType tmp;
    for (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;
    }
}


void ShellSort( ElementType A[], int N )
{
    int P, i, D, Si;
    ElementType tmp;
    int Sedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};
    
    for (Si = 0; Sedgewick[Si] >= N; Si++);
    
    for(D = Sedgewick[Si]; Sedgewick[Si] > 0; D = Sedgewick[++Si]) {
        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;
        }
    }
}


void Swap( ElementType *a, ElementType *b)
{
    int t;
    t = *a;
    *a = *b;
    *b = t;
    
}
void PercDown( ElementType A[], int P, int N )
{
    
    int Parent, Child;
    ElementType X;
    
    X = A[P];
    
    for (Parent = P; Parent*2+1 <= N-1; Parent = Child) {
        Child = Parent * 2 + 1;
        if ( Child < (N-1) and A[Child+1] > A[Child] ) {
            Child++;
        }
        if (X > A[Child]) {
            break;
        }
        else {
            A[Parent] = A[Child];
        }
    }
    A[Parent] = X;
    
}
void HeapSort( ElementType A[], int N)
{
    for (int i = (N-1)/2 ; i>=0; i--) {
        PercDown(A, i, N);
    } //buildMaxHeap
    
    for(int i=N-1; i>0; i--) {
        Swap(&A[0], &A[i]);
        PercDown(A, 0, i);
    }
    
}


void Merge( ElementType A[], ElementType TmpA[], int L, int R, int RightEnd )
{
    int TmpInd, LeftEnd, NumElements;
    TmpInd = L;
    LeftEnd = R-1;
    NumElements = RightEnd - L + 1;
    
    while (L <= LeftEnd && R <= RightEnd) {
        if (A[L] < A[R]) {
            TmpA[TmpInd++] = A[L++];
        }
        else TmpA[TmpInd++] = A[R++];
    }
    
    while (L <= LeftEnd) {
        TmpA[TmpInd++] = A[L++];
    }
    while (R <= RightEnd) {
        TmpA[TmpInd++] = A[R++];
    }
    for (int i=0; i<NumElements; i++) {
        A[RightEnd] = TmpA[RightEnd];
        RightEnd--;
    }
    
}
void Msort( ElementType A[], ElementType TmpA[], int L, int RightEnd)
{
    int center;
    if (L < RightEnd) {
        center = (RightEnd + L) / 2;
        Msort(A, TmpA, L, center);
        Msort(A, TmpA, center+1, RightEnd);
        Merge(A, TmpA, L, center+1, RightEnd);
    }
}
//Recursive_mergeSort
void MergeSort( ElementType A[], int N )
{
    ElementType * TmpA = (ElementType *) malloc( N * sizeof(ElementType) );
    if (TmpA == NULL) {
        printf("MEMORY INSUFFICIENT");
    }
    Msort(A, TmpA, 0, N-1);
    free(TmpA);
}
//Non-recursive_mergeSort
void MergeSort2( ElementType A[], int N )
{
    int length, i;
    ElementType * TmpA;
    TmpA = (ElementType *) malloc( N * sizeof(ElementType) );
    
    for (length = 1; length <= N; length *= 2) {
        
        for (i = 0; i < N-2*length; i += 2*length) {
            Merge(A, TmpA, i, i+length, i+2*length-1);
        }
        if (i + length < N) {
            Merge(A, TmpA, i, i+length, N-1);
        }
        
    }
}

//"algorithm" function sort(, , )
void LibQuickSort( ElementType A[], int N )
{
    sort(A, A+N);
}

//SelfWritten QSort

ElementType Median3(ElementType A[], int L, int R)//三元中值法
{
    int Center;
    Center = (L + R)/2;
    if (A[L] > A[Center]) {
        Swap( &A[L], &A[Center] );
    }
    if (A[L] > A[R]) {
        Swap( &A[L], &A[R] );
    }
    if (A[Center] > A[R]) {
        Swap( &A[Center], &A[R] );
    }
    Swap( &A[Center], &A[R-1] );  //Pivot locates at A[R-1]
    return A[R-1];
}
void QSort( ElementType A[], int L, int R )
{
    int NumEle, Pivot, i, j;
    NumEle = R - L + 1;
    
    if( NumEle >= CUTOFF ){
        Pivot = Median3(A, L, R);
        i = L + 1 ;
        j = R - 2;
        
        while(1) {
            while( A[i] < Pivot && i<R ) i++;
            while (A[j] > Pivot && j>L) j--;
            if(i < j) Swap(&A[i], &A[j]); //??? ==?
            else break;
        }
        Swap(&A[i], &A[R-1]); //Pivot translocates in A[i];
        
        QSort(A, L, i-1);
        QSort(A, i+1, R);
        
    }
    else InsertionSort(A + L, NumEle);
    
    
}
void QSort2( ElementType A[], int L, int R )//直接选A[0]
{
    int NumEle, Pivot, i, j;
    NumEle = R - L + 1;
    
    if( NumEle >= CUTOFF ){
        Pivot = A[L];
        i = L ;
        j = R + 1 ;
        
        while(1) {
            while( A[++i] < Pivot && i < R);
            while (A[--j] > Pivot && j > L);
            if(i < j) swap(A[i], A[j]); //??? ==?
            else break;
        }
        swap(A[j], A[L]); //Pivot translocates in A[i];
        
        
        QSort2(A, L, j-1);
        QSort2(A, j+1, R);
        
    }
    else InsertionSort(A + L, NumEle);
    
}
void QuickSort(ElementType A[], int N)
{
    QSort(A, 0, N-1);
}



int arr[maxn];
int main() {
    int N;
    scanf("%d", &N);
    for(int i=0; i<N; i++) {
        scanf("%d", arr+i);
    }
    QuickSort(arr, N);
    printf("%d", arr[0]);
    
    for(int i=1; i<N; i++) {
        printf(" %d", *(arr + i ) );
    }
    printf("\n");
    
    
    return 0;
}