采用顺序存储结构,完成顺序表的创建,实现对顺序表的直接插入排序，快速排序，选择排序，归并排序

好的，我来依次回答你的问题。

首先，顺序存储结构可以使用数组来实现。创建一个顺序表需要以下几个步骤：

1. 定义顺序表的数据类型。例如，如果要创建一个整型的顺序表，可以定义如下结构体：

#define MAXSIZE 100  // 定义顺序表的最大长度

typedef struct {
    int data[MAXSIZE];  // 存储数据的数组
    int length;  // 当前顺序表的长度
} SqList;  // 顺序表类型的别名

2. 初始化顺序表。顺序表创建完成后，需要先给它赋初值。一般情况下，可以将顺序表的长度设置为0，表示当前顺序表为空。

void InitList(SqList *L) {
    L->length = 0;
}

3. 插入元素。在顺序表中插入元素时，需要保证插入后的元素仍然是有序的。这里我们使用直接插入排序、快速排序、选择排序和归并排序四种排序算法来实现。

以下是四种排序算法的具体实现：

1. 直接插入排序

void InsertSort(SqList *L) {
    int i, j, tmp;
    for (i = 1; i < L->length; i++) {
        if (L->data[i] < L->data[i-1]) {
            tmp = L->data[i];
            for (j = i-1; j >= 0 && L->data[j] > tmp; j--) {
                L->data[j+1] = L->data[j];
            }
            L->data[j+1] = tmp;
        }
    }
}

2. 快速排序

int Partition(SqList *L, int low, int high) {
    int pivot = L->data[low];
    while (low < high) {
        while (low < high && L->data[high] >= pivot) {
            high--;
        }
        L->data[low] = L->data[high];
        while (low < high && L->data[low] <= pivot) {
            low++;
        }
        L->data[high] = L->data[low];
    }
    L->data[low] = pivot;
    return low;
}

void QuickSort(SqList *L, int low, int high) {
    if (low < high) {
        int pivotpos = Partition(L, low, high);
        QuickSort(L, low, pivotpos-1);
        QuickSort(L, pivotpos+1, high);
    }
}

3. 选择排序

void SelectSort(SqList *L) {
    int i, j, k, tmp;
    for (i = 0; i < L->length-1; i++) {
        k = i;
        for (j = i+1; j < L->length; j++) {
            if (L->data[j] < L->data[k]) {
                k = j;
            }
        }
        if (k != i) {
            tmp = L->data[i];
            L->data[i] = L->data[k];
            L->data[k] = tmp;
        }
    }
}

4. 归并排序

void Merge(int *a, int *b, int left, int mid, int right) {
    int i, j, k;
    for (i = left; i <= right; i++) {
        b[i] = a[i];
    }
    i = left;
    j = mid + 1;
    k = left;
    while (i <= mid && j <= right) {
        if (b[i] <= b[j]) {
            a[k++] = b[i++];
        } else {
            a[k++] = b[j++];
        }
    }
    while (i <= mid) {
        a[k++] = b[i++];
    }
    while (j <= right) {
        a[k++] = b[j++];
    }
}

void MergeSort(int *a, int *b, int left, int right) {
    if (left < right) {
        int mid = (left + right) / 2;
        MergeSort(a, b, left, mid);
        MergeSort(a, b, mid+1, right);
        Merge(a, b, left, mid, right);
    }
}

void MergeSortWrapper(SqList *L) {
    int b[MAXSIZE];
    MergeSort(L->data, b, 0, L->length-1);
}

这里为了方便，我们将归并排序单独实现了一个包装函数。

上述四种排序算法都是针对顺序表的直接排序算法。它们的时间复杂度分别为$O(n^2)$、$O(nlogn)$、$O(n^2)$和$O(nlogn)$。如果需要对链式存储结构的线性表进行排序，需要使用其他算法。