王道8.6

#include "stdio.h"
#include "stdlib.h"
typedef int ElemType;
typedef struct LNode{
    ElemType data;
    struct LNode* next;
}LNode,*LinkList;
//不带头结点
void selectSort(LinkList* L) {
    LNode * h = L, * p, * q, * r, * s;
    L = NULL;
    while (h != NULL) {
        p = s = h;
        q = r = NULL;
        while (p != NULL) {
            if (p->data > s->data) {
                s = p;
                r = q;
            }
            q = p;
            p = p->next;
        }
        if (s == h)
            h = h->next;
        else
            r->next = s->next;
        s->next = L;
        L = s;
    }
}
//判断一个数据序列是否构成一个小根堆，扫描所有分支结点，遇到孩子结点的关键字小于根结点的关键字时返回false,扫描完后返回true
int IsMinHeap(ElemType A[], int len) {
    int i;
    if (len % 2 == 0) {//len为偶数，有一个单分支结点
        if (A[len / 2] > A[len])//判断单分支结点
            return 0;
        for (i = len / 2 - 1; i >= 1; i--)//判断所有双分支结点
            if (A[i] > A[2 * i] || A[i] > A[2 * i + 1])
                return 0;
    }
    else {//len为奇数时，没有单分支结点
        for (i = len / 2; i >= 1; i--)//判断所有双分支结点
            if (A[i] > A[2 * i] || A[i] > A[2 * i + 1])
                return 0;
    }
    return 1;
}
//顺序表前m个元素递增有序，后n个元素递增有序
//将数组A[1...m+n]视为一个已经过m趟插入排序的表，则从m+1趟开始，将后n个元素依次插入到前面的有序表中
void InsertSort(ElemType A[], int m, int n) {
    int i, j;
    for (i = m + 1; i <= m + n; i++) {
        A[0] = A[i];
        for (j = i - 1; A[j] > A[0]; j--)
            A[j + 1] = A[j];
        A[j + 1] = A[0];
    }
}
//计数排序，统计关键字比它小的元素个数，然后把它放入另一个数组对应的位置上
void CountSort(ElemType A[], ElemType B[], int n) {
    int count;
    int i, j;
    for (i = 0; i < n; i++) {
        for (j = 0, count = 0; j < n; j++)
            if (A[j] < A[i])
                count++;
        B[count] = A[i];
    }
}
//计数排序优化，任意两个记录之间只比较一次
void CountSortt(ElemType A[], ElemType B[], int n) {
    int i, j;
    int count;
    for (i = 0; i < n; i++)
        A[i].count=0;
    for (i = 0; i < n; i++) {
        for (j = i + 1; j < n; j++)
            if (A[i] < A[j])
                A[j].count++;
            else
                A[i].count++;
        B[A[i].count] = A[i];
    }
}

//以kn为枢轴进行一次快速排序
int Partition(ElemType K[], int n) {
    int i = 1, j = n;
    ElemType pivot = K[j];
    while (i < j) {
        while (i < j && K[i] <= pivot)
            i++;
        if (i < j)
            K[j] = K[i];
        while (i < j && K[j] >= pivot)
            j--;
        if (i < j)
            K[i] = K[j];
    }
    K[i] = pivot;
    return i;
}