#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;
}