经典排序算法

1简单插入排序：

void Insert_Sort(ElementType A[], int N) {    for(P=1; P<N; P++) {        Tmp = A[P];//摸下一张牌        for(i=P; i>0 && A[P-1]>Tmp; i--) {            A[i] = A[i-1];//移出空位        }        A[i] = Tmp;//新牌位置    }}

最好情况：T=O(N)
最坏情况：T=O(N2)

2希尔排序
希尔排序又称”缩小增量排序”。定义增量序列Dm > Dm−1 >…>D1 = 1

void ShellSort(ElementType A[], int N) {    int Si, D, P, i;    ElementType Tmp;    int Dedgewick[] = {929, 505, 209, 109, 41, 19, 5, 1, 0};//使用Dedgewick增量序列    for(Si=0; Sedgewick[Si]>=N; Si++) ;    for(D=Sedgewick[Si]; D>0; D=Sedgewick[++Si]) {        for(P=D; P<N; P++){            Tmp = A[P];            for(i=P; i>=0 && A[i-D]>Tmp; i-=D) {                A[i] = A[i-D];            }            A[i] = Tmp;        }    }}

Hibbard增量序列：
Dk = 2k-1 相邻元素互质
最坏情况：T=O(N3/2)
平均情况：T=O(N5/4)
Sedgewick增量序列
{1，5，19，109，…}
9x4i-9x2i+1 或者 4i-3x2i+1
最坏情况：T=O(N4/3)
平均情况：T=O(N7/6)

3选择排序
基本思路是每一趟在n-i+1个记录中选择最小的记录作为第i
个元素。

void Selection_Sort(ElementType A[], int N) {    for(i=0; i<N; i++) {        MinPosition = ScanForMin(A, i, N-1);        Swip(A[i], A[MinPosition]);    }}

时间复杂度T(N2)
堆排序一种树形选择排序，只需要一个记录大小的存储空间

void Swap(ElementType *a, ElementType *b) {    ElementType 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; Parent = Child) {        Child = Parent*2+1;        if(((Child!=N-1) && (A[Child]<A[Child+1]))) {                Child+=1;        }        if(X >= A[Child])break;//找到合适位置        eles A[Parent] = A[Child];    }    A[Parent] = X;}void HeapSort(ElementType A[], int N) {    int i=1;    for(i=N/2-1; i>=0; i--) {//建立最大堆        PercDown(A, i, N);    }    for(i=N-1; i>0; i--) {        Swap(&A[0], &A[i]);        PercDown(A, 0, i);    }}

最好情况：T=O(NlogN)
最坏情况：T=O(NlogN)

4快速排序
快排采用分治思想将一个序列分成两个子序列。

void Qsort(ElementType A[], int Left; int Right) {    int Pivot, Low, High;    Pivot = Median3(A, Left, Right);//选取基准    Low = Left; High = Right-1;    while(1) {        while(A[Low++] < Pivot){}        while(A[High--] > Pivot){}        if(Low < High) Swap(&A[Low], &A[High]);        else break;     }    Swap(&A[Low], &A[Right-1]);    Qsort(A, Left, Low-1);    Qsort(A, Low+1, Right);}

最好情况：T=O(NlogN)
最坏情况：T=O(N2)
5归并排序

void Marge(ElementType A[], ElementType TmpA[], int L, int R, int RightEnd) {    int LeftEnd, NumElements, Tmp;    int i;    LeftEnd = R - 1;    Tmp = L;    NumElements = RightEnd - L - 1;    while(L<=LeftEnd && R<=RightEnd) {        if(A[L] <= A[R]) {            TmpA[Tmp++] = A[L++];        } else {            TmpA[Tmp++] = A[R++];        }    }    while(L <= LeftEnd) {        TmpA[Tmp++] = A[L++];    }    while(R <= RightEnd) {        TmpA[Tmp++] = A[R++];    }    for(i=0; i<NumElements; i++, RightEnd--) {        A[RightEnd] = TmpA[RightEnd];    }}void Msort(ElementType A[], ElementType TmpA[], int L, int RightEnd) {    int center;    if(L < RightEnd) {        center = (L+RightEnd)/2;        Msort(A, TmpA, L, Center);        Msort(A, TmpA, Center+1, RightEnd);        Marge(A, TmpA, L, Center+1, RightEnd);    }}

时间复杂度T( N ) = O( N logN )，需要额外空间O(N)

6基数排序
输入序列：64, 8, 216, 512, 27, 729, 0, 1, 343, 125 。T=O(P(N+B))

//基数排序#define MaxDigit 4//关键字个数#define Radix 10//基数typedef struct Node *PtrToNode;strut Node{    int key;    PtrToNode next;};//桶元素节点struct HeadNode {    PtrToNode head, tail;};//桶头结点typedef strut HeadNode Bucket[Radix];int GetDigit(int X, int D) {    int d, i;    for(i=1; i<=D; i++) {        d = X%Radix;        x /= Raddix;    }    return d;}void LSDEadixSort(ElementType A[], int N) {    int D, Di, i;    Bucket B;    PtrToNode tmp, p, List = NULL;    for(i=0; i<Radix; i++) {        B[i].head = B[i].tail = NULL;    }    for(i=0; i<N; i++) {        tmp = (PtrToNode)malloc(sizeof(struct Node));        tmp->key = A[i];        tmp->next = List;        List = tmp;    }    for(D=1; D<=MaxDigit; D++) {        p = List;        while(p) {            Di = GetDigit(p->key, D);//获取当前元素的当前数字            tmp=p; p=p->next;            tmp->next = NULL;            if(B[Di].head == NULL) {                B[Di].head = B[Di].tail = tmp;            } else {                B[Di].tail->next = tmp;                B[Di].tail = tmp;               }           }        List = NULL;        for(Di=Radix-1; Di>=0; Di--) {//将每个桶的元素顺序收集入List            if(B[Di].head) {//整桶插入List表头                 B[Di].tail->next = List;                List = B[Di].head;                B[Di].head = B[Di].tail = NULL;//清空桶            }        }    }    for(i=0; i<N; i++) {        tmp = List;        List = List->next;        A[i] = tmp->key;        free(tmp);    }}

平均时间复杂度O(P(N+B))，空间复杂度O(N+B)