c++语言编程实现以下排序算法： 1. 直接插入排序算法； 2. 冒泡排序算法； 3. 快速排序算法； 4. 简单选择排序算法； (要求:设置哨兵监视，使用typedef定义关键字类型和哨兵，以及顺序表类型与记录类型)

好的，以下是四个排序算法的实现代码：

#include <iostream>
#include <vector>
#include <ctime>
using namespace std;

typedef int KeyType;
typedef struct {
    KeyType key;
} ElemType;

typedef struct {
    ElemType *data;
    int length;
} SqList;

typedef SqList *ListPtr;

// 直接插入排序算法
void InsertSort(ListPtr L) {
    int i, j;
    for (i = 2; i <= L->length; i++) {
        if (L->data[i].key < L->data[i - 1].key) {
            L->data[0] = L->data[i];
            L->data[i] = L->data[i - 1];
            for (j = i - 2; L->data[0].key < L->data[j].key; j--) {
                L->data[j + 1] = L->data[j];
            }
            L->data[j + 1] = L->data[0];
        }
    }
}

// 冒泡排序算法
void BubbleSort(ListPtr L) {
    int i, j, flag;
    for (i = L->length; i >= 2; i--) {
        flag = 0;
        for (j = 1; j < i; j++) {
            if (L->data[j].key > L->data[j + 1].key) {
                swap(L->data[j], L->data[j + 1]);
                flag = 1;
            }
        }
        if (flag == 0) return;
    }
}

// 快速排序算法
void QuickSort(ListPtr L, int low, int high) {
    if (low < high) {
        int i = low, j = high;
        ElemType pivot = L->data[low];
        while (i < j) {
            while (i < j && L->data[j].key >= pivot.key) j--;
            if (i < j) L->data[i++] = L->data[j];
            while (i < j && L->data[i].key <= pivot.key) i++;
            if (i < j) L->data[j--] = L->data[i];
        }
        L->data[i] = pivot;
        QuickSort(L, low, i - 1);
        QuickSort(L, i + 1, high);
    }
}

// 简单选择排序算法
void SelectSort(ListPtr L) {
    int i, j, min;
    for (i = 1; i <= L->length - 1; i++) {
        min = i;
        for (j = i + 1; j <= L->length; j++) {
            if (L->data[j].key < L->data[min].key) {
                min = j;
            }
        }
        if (min != i) {
            swap(L->data[i], L->data[min]);
        }
    }
}

// 打印顺序表
void PrintList(ListPtr L) {
    for (int i = 1; i <= L->length; i++) {
        cout << L->data[i].key << " ";
    }
    cout << endl;
}

int main() {
    srand(time(NULL));

    // 初始化顺序表
    ListPtr L = new SqList;
    L->length = 10;
    L->data = new ElemType[L->length + 1];
    for (int i = 1; i <= L->length; i++) {
        L->data[i].key = rand() % 100;
    }

    // 打印顺序表
    cout << "原始顺序表: ";
    PrintList(L);

    // 直接插入排序
    ListPtr L1 = new SqList;
    *L1 = *L;
    InsertSort(L1);
    cout << "直接插入排序: ";
    PrintList(L1);

    // 冒泡排序
    ListPtr L2 = new SqList;
    *L2 = *L;
    BubbleSort(L2);
    cout << "冒泡排序: ";
    PrintList(L2);

    // 快速排序
    ListPtr L3 = new SqList;
    *L3 = *L;
    QuickSort(L3, 1, L3->length);
    cout << "快速排序: ";
    PrintList(L3);

    // 简单选择排序
    ListPtr L4 = new SqList;
    *L4 = *L;
    SelectSort(L4);
    cout << "简单选择排序: ";
    PrintList(L4);

    return 0;
}

以上代码中，我们使用了 `typedef` 定义了关键字类型 `KeyType` 和记录类型 `ElemType`，并且使用了一个 `SqList` 结构体来表示顺序表，其中包含了一个指向 `ElemType` 数组的指针和顺序表的长度。我们还定义了一个 `ListPtr` 类型来表示指向 `SqList` 结构体的指针。

对于每个排序算法，我们都使用了相应的函数来实现。其中，直接插入排序算法使用了哨兵监视，冒泡排序算法使用了标志位进行优化，快速排序算法使用了递归实现，简单选择排序算法则使用了双重循环。最后，我们在 `main` 函数中初始化了一个随机的顺序表，并依次使用四个排序算法对其进行排序，并打印出排序结果。