典型排序算法（C语言实现）

  《数据结构（C语言版）》的最后一次实验作业（排序），要求如下：

数据结构实验5：排序 要求： 1、直接插入排序； 2、shell 排序； 3、简单选择排序； 4、快速排序； 5、堆排序（选做）；

  分享一下我（@ tongtongxyz）的小作业吧。

/***************************************
 *  Filename: sort.cpp                 *
 *  Function: 典型排序算法             *
 *  Author: TongtongXyz                *
 *  Weibo: @tongtongxyz                *
 *  Date: 20130112                     *
 ***************************************/
#include <stdio.h>
#include <stdlib.h>
#define MAXSIZE 100    //排序元素数
typedef int KeyType;
typedef int InfoType;
typedef struct{
    KeyType key;
    InfoType otherinfo;
}RedType;
typedef struct{
    RedType r[MAXSIZE+1];
    int length;
}SqList;
typedef SqList HeapType;
void InsertSort(SqList &L){
    //直接插入排序
    int i, j;
    for(i = 2; i <= L.length; ++i){
        if(L.r[i].key < L.r[i-1].key){
            L.r[0] = L.r[i];
            L.r[i] = L.r[i-1];
            for(j = i - 2; L.r[0].key < L.r[j].key; --j){
                L.r[j+1] = L.r[j];
            }
            L.r[j+1] = L.r[0];
        }
    }
}
void SortOutput(SqList &L){
    printf("当前顺序表中的关键字序列为：\n");
    for(int i = 1; i <= L.length; i++){
        printf("%d  ", L.r[i].key);
    }
    printf("\n\n");
}
void SortInput(SqList &L, KeyType key){
    L.r[++L.length].key = key;
}
void ShellInsert(SqList &L, int dk){
    int i, j;
    for(i = dk + 1; i <= L.length; ++i){
        if(L.r[i].key < L.r[i-dk].key){
            L.r[0] = L.r[i];
            for(j = i - dk; j > 0 && L.r[0].key < L.r[j].key; j -= dk){
                L.r[j+dk] = L.r[j];
            }
            L.r[j+dk] = L.r[0];
        }
    }
}
void ShellSort(SqList &L, int dlta[], int t){
    //shell排序
    int k;
    for(k = 0; k < t; ++k){
        dlta[k] = 2^(t-k+1) - 1;
        ShellInsert(L, dlta[k]);
    }
}
int SelectMinKey(SqList L, int i){
    KeyType minkey;
    for(minkey = i; i <= L.length; i++){
        if(L.r[minkey].key > L.r[i].key){
            minkey = i;
        }
        //minkey = ((L.r[i].key < L.r[i+1].key) ? i : (i+1));
    }
    return minkey;
}
void SelectSort(SqList &L){
    //简单选择排序
    int i, j;
    for(i = 1; i < L.length; ++i){
        j = SelectMinKey(L, i);
        if(i != j){
            L.r[0] = L.r[i];
            L.r[i] = L.r[j];
            L.r[j] = 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.r[high];
        while(low < high && L.r[low].key<= pivotkey){
            ++low;
        }
        L.r[high] = L.r[low];
    }
    L.r[low] = L.r[0];
    return low;
}
void Qsort(SqList &L, int low, int high){
    KeyType pivotloc;
    if(low < high){
        pivotloc = Partition(L, low, high);
        Qsort(L, low, pivotloc - 1);
        Qsort(L, pivotloc + 1, high);
    }
}
void QuickSort(SqList &L){
    //快速排序
    Qsort(L, 1, L.length);
}
void HeapAdjust(HeapType &H, int s, int m){
    RedType rc;
    int j;
    rc = H.r[s];
    for(j = 2 * s; j <= m; j *= 2){
        if(j < m && H.r[j].key < H.r[j+1].key){
            ++j;
        }
        if(!(rc.key < H.r[j].key)){
            break;
        }
        H.r[s] = H.r[j]; s = j;
    }
    H.r[s] = rc;
}
void HeapSort(HeapType &H){
    //堆排序
    int i;
    for(i = H.length/2; i > 0; --i){
        HeapAdjust(H, i, H.length);
    }
    for(i = H.length; i > 1; --i){
        H.r[0] = H.r[1];
        H.r[1] = H.r[i];
        H.r[i] = H.r[0];
        HeapAdjust(H, 1, i - 1);
    }
}
int main(void){
    SqList L;
    L.length = 0;
    int t = 4;    //shell排序参数t
    int dlta[t];   //shell排序参数dlta[]
    KeyType key;
    while(1){
        int option;
        printf("请选择排序算法：\n1. 直接插入排序;\n2. shell 排序\n3. 简单选择排序\n4. 快速排序\n5. 堆排序\n注：“ctrl+c”退出程序，“ctrl+z”输入文件结束符EOF\n请输入选择并回车确认:");
        scanf("%d", &option);
        printf("请输入关键字序列(以EOF结束)并回车确认：");
        while(scanf("%d", &key) != EOF){
        SortInput(L, key);
    }
        switch(option){
            case 1 :
                InsertSort(L);
                break;
            case 2 :
                ShellSort(L, dlta, t);
                break;
            case 3 :
                SelectSort(L);
                break;
            case 4 :
                QuickSort(L);
                break;
            case 5 :
                HeapSort(L);
                break;
            default:
                printf("您输入的参数有误，请重新输入！\n");
        }
        SortOutput(L);
    }
    return 0;
}