经典排序算法

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($N^2$)

2希尔排序
希尔排序又称”缩小增量排序”。定义增量序列$D_{m}$ > $D_{m-1}$ >$\ldots$>$D_1$ = 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增量序列：
$D_k$ = $2^k$-1 相邻元素互质
最坏情况：T=O($N^{3/2}$)
平均情况：T=O($N^{5/4}$)
Sedgewick增量序列
{1，5，19，109，$\ldots$}
9x$4^i$-9x$2^i$+1 或者 $4^i$-3x$2^i$+1
最坏情况：T=O($N^{4/3}$)
平均情况：T=O($N^{7/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($N^2$)
堆排序一种树形选择排序，只需要一个记录大小的存储空间

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)