（1）输入一组整型元素序列，建立顺序表。 ⑵实现该顺序表的遍历。 ⑶在该顺序表中进行顺序查找某一元素，查找成功返回1，否则返回0。 ⑷判断该顺序表中元素是否对称，对称返回1，否则返回0。 ⑸实现把该表中所有奇数排在偶数之前，即表的前面为奇数，后面为偶数。 ⑹输入整型元素序列利用有序表插入算法建立一个有序表。 ⑺利用算法6建立两个非递减有序表并把它们合并成一个非递减有序表。 编写一个主函数，调试上述算法。

我可以回答这个问题。以下是我的回答：

1. 建立顺序表的代码实现：

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

typedef struct {
    int data[MAXSIZE]; // 存储顺序表元素的数组
    int length; // 顺序表的长度
} SqList;

// 初始化顺序表
void InitList(SqList *L) {
    L->length = 0;
}

// 插入元素到顺序表中
int InsertList(SqList *L, int elem) {
    if (L->length >= MAXSIZE) {
        return 0; // 顺序表已满，插入失败
    }
    L->data[L->length] = elem;
    L->length++;
    return 1; // 插入成功
}

2. 遍历顺序表的代码实现：

// 遍历顺序表
void TraverseList(SqList L) {
    int i;
    for (i = 0; i < L.length; i++) {
        printf("%d ", L.data[i]);
    }
    printf("\n");
}

3. 顺序查找某一元素的代码实现：

// 顺序查找元素
int SearchList(SqList L, int elem) {
    int i;
    for (i = 0; i < L.length; i++) {
        if (L.data[i] == elem) {
            return 1; // 查找成功
        }
    }
    return 0; // 查找失败
}

4. 判断顺序表是否对称的代码实现：

// 判断顺序表是否对称
int IsSymmetricList(SqList L) {
    int i, j;
    for (i = 0, j = L.length - 1; i < j; i++, j--) {
        if (L.data[i] != L.data[j]) {
            return 0; // 不对称
        }
    }
    return 1; // 对称
}

5. 把顺序表中所有奇数排在偶数之前的代码实现：

// 把顺序表中所有奇数排在偶数之前
void SortList(SqList *L) {
    int i, j, temp;
    for (i = 0, j = L->length - 1; i < j;) {
        if (L->data[i] % 2 == 1) {
            i++;
        } else if (L->data[j] % 2 == 0) {
            j--;
        } else {
            temp = L->data[i];
            L->data[i] = L->data[j];
            L->data[j] = temp;
            i++;
            j--;
        }
    }
}

6. 利用有序表插入算法建立一个有序表的代码实现：

// 利用有序表插入算法建立一个有序表
void CreateOrderList(SqList *L) {
    int i, elem;
    InitList(L);
    printf("请输入元素个数：");
    scanf("%d", &L->length);
    printf("请输入元素：");
    for (i = 0; i < L->length; i++) {
        scanf("%d", &elem);
        InsertOrderList(L, elem);
    }
}

// 有序表插入算法
void InsertOrderList(SqList *L, int elem) {
    int i, j;
    for (i = 0; i < L->length && L->data[i] < elem; i++);
    for (j = L->length; j > i; j--) {
        L->data[j] = L->data[j - 1];
    }
    L->data[i] = elem;
    L->length++;
}

7. 合并两个非递减有序表并把它们合并成一个非递减有序表的代码实现：

// 合并两个非递减有序表并把它们合并成一个非递减有序表
void MergeOrderList(SqList L1, SqList L2, SqList *L3) {
    int i, j, k;
    i = j = k = 0;
    while (i < L1.length && j < L2.length) {
        if (L1.data[i] <= L2.data[j]) {
            L3->data[k] = L1.data[i];
            i++;
        } else {
            L3->data[k] = L2.data[j];
            j++;
        }
        k++;
    }
    while (i < L1.length) {
        L3->data[k] = L1.data[i];
        i++;
        k++;
    }
    while (j < L2.length) {
        L3->data[k] = L2.data[j];
        j++;
        k++;
    }
    L3->length = k;
}

8. 主函数的代码实现：

int main() {
    SqList L, L1, L2, L3;
    int i, elem, result;

    // 建立顺序表
    InitList(&L);
    printf("请输入元素个数：");
    scanf("%d", &L.length);
    printf("请输入元素：");
    for (i = 0; i < L.length; i++) {
        scanf("%d", &elem);
        InsertList(&L, elem);
    }

    // 遍历顺序表
    printf("顺序表元素为：");
    TraverseList(L);

    // 顺序查找元素
    printf("请输入要查找的元素：");
    scanf("%d", &elem);
    result = SearchList(L, elem);
    if (result == 1) {
        printf("查找成功\n");
    } else {
        printf("查找失败\n");
    }

    // 判断顺序表是否对称
    result = IsSymmetricList(L);
    if (result == 1) {
        printf("顺序表对称\n");
    } else {
        printf("顺序表不对称\n");
    }

    // 把顺序表中所有奇数排在偶数之前
    SortList(&L);
    printf("奇偶排序后的顺序表为：");
    TraverseList(L);

    // 利用有序表插入算法建立一个有序表
    CreateOrderList(&L1);
    printf("有序表1为：");
    TraverseList(L1);
    CreateOrderList(&L2);
    printf("有序表2为：");
    TraverseList(L2);

    // 合并两个非递减有序表并把它们合并成一个非递减有序表
    MergeOrderList(L1, L2, &L3);
    printf("合并后的有序表为：");
    TraverseList(L3);

    return 0;
}