数据结构：排序

#define MAX_SIZE 20
typedef int KeyType;
struct RedType //记录类型
{
    KeyType key; //关键字项
    InfoType otherinfo;
};
struct SqList //顺序表类型
{
    RedType r[MAX_SIZE + 1]; //r[0]闲置或作为哨兵
    int length;
};

//直插
void InsertSort(SqList &L)
{
    int i, j;
    for(i = 2; i <= L.length; ++i)
        if(LT(L.r[i].key, L.r[i-1].key))
        {
            L.r[0] = L.r[i]; //复制为哨兵
            for(j = i - 1; LT(L.r[0].key, L.r[j].key); --j)  //从后向前进行比较
                L.r[j+1] = L.r[j]; //记录后移
            L.r[j+1] = L.r[0]; //插入到正确位置
        }
}

//折半  要求有序子表
void BInsertSort(SqList &L)
{
    int i, j ,m, low, high;
    for(i = 2; i < L.length; ++i)
    {
        L.r[0] = L.r[i];
        low = 1;
        high = i - 1;
        while(low <= high) //找到正确的插入位置
        {
            m = (low + high) / 2
            if(LT(L.r[0].key, L.r[m].key))
                high = m - 1;
            else
                low = m - 1;
        }
        for(j = i - 1; j >= high + 1; --j)
            L.r[j+1]=L.r[j]; //记录后移
        L.r[high+1] = L.r[0]; //插入到正确位置
    }
}
//快排
int Partition(SqList *L, int low, int high)
{ //枢轴记录到位，并返回其位置，使其之前的记录小于它，之后记录大于它
    KeyType pivotkey;
    L.r[0] = L.r[low];
    pivotkey = L.r[low].key; //子表第一记录作为枢轴
    while(low < high)
    {
        while(low < high && L.r[high].key >= pivotkey)
            --high;
        L.r[low] = L.[high];
        while(low < high && L.r[low].key <= pivotkey)
            ++low;
        L.r[high] = L.r[low];
    }
    return low; //返回最后枢轴的位置
}
void QSort(SqList &L, int low, int high)
{ //对顺序表的子序列做快排
    int pivotloc;
    if(low < high)
    {
        pivotloc = Partition(L, low, high);
        QSort(L, low, pivotloc-1);
        QSort(L, pivotloc+1, high);
    }
}

//简单选择
int SelectMinKey(SqList L, int i)
{ //返回在H.r[i...L.length]中key最小的记录的序号
    KeyType min;
    int j, k;
    k = i; //设第i个最小
    min = L.r[i].key;
    for(j = i + 1; j <= L.length; j++)
        if(LT(L.r[j].key, min))
        {
            min = L.r[j].key;
            k = j;
        }
    return k;
}
void SelectSort(SqList &L)
{
    int i, j;
    RedType t;
    for(i = 1; i <L.length; ++i)
    {
        j = SelectMinKey(L, i);
        if(i != j)
        {
            t = L.r[i];
            L.r[i] = L.r[j];
            L.r[j] = t;
        }
    }
}

//堆
typedef SqList HeapType;
void HeapAdjust(HeapType &H, int s, int m)
{ //使H.r[s...m]成为大顶堆
    RedType rc
    rc = H.r[s];
    int j;
    for(j = 2 * s; j <= m; j *=2 )
    {
        if(j < m && LT(H.r[j].key, H.r[j + 1]))
            ++j;
        if(!LT(rc.key, H.r[j].key)) //rc应该插在位置s上
            break;
        H.r[s] = H.r[j];
        s = j;
    }
    H.r[s] = rc;
}
void HeapSort(HeapType &H)
{
    RedType t;
    int i;
    for(i = H.length / 2; i > 0; --i) //将H.r[1...H.length]调成大顶堆
        HeapAdjust(H, i, H.length);
    for(i = H.length; i > 1; --i) //将堆顶记录与之前未经排序子序列H.r[1...i]中最后一个记录相互交换
    {
        t = H.r[1];
        H.r[1] = H.r[i];
        H.r[i] = t;
        HeapAdjust(H, 1, i-1);
    }
}