用C语言设计一个程序，可实现以下内容（并且在每行代码后面进行解释说明）：1.任意输入前序+中序序列（或中序+后序序列），生成唯一的二叉树，并打印其的后序序 列（或前序序列）（当用户输入错误的序列无法生成二叉树时，程序应该有错误提示）； 2. 判断输入的一棵二叉树是否是二叉搜索树； 3. 输入一棵二叉搜索树，求出其中的最小和最大关键字； 4. 将该二叉搜索树转换成一个排序的双向链表（要求不能创建任何新的结点，只能调整树 中结点指针的指向）。

以下是代码及注释：

#include <stdio.h>
#include <stdlib.h>

// 定义二叉树结点
typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
} TreeNode;

// 根据前序+中序序列构建二叉树
TreeNode* buildTree(int* preorder, int* inorder, int preorderSize, int inorderSize) {
    if (preorderSize <= 0 || inorderSize <= 0) { // 当序列长度为0时，返回NULL
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode)); // 创建根结点
    root->val = preorder[0];
    int i;
    for (i = 0; i < inorderSize; i++) { // 在中序序列中找到根结点的位置
        if (inorder[i] == preorder[0]) {
            break;
        }
    }
    if (i == inorderSize) { // 如果没找到，说明序列有误，返回NULL
        free(root);
        return NULL;
    }
    root->left = buildTree(preorder + 1, inorder, i, i); // 递归构建左子树
    root->right = buildTree(preorder + i + 1, inorder + i + 1, preorderSize - i - 1, inorderSize - i - 1); // 递归构建右子树
    return root;
}

// 打印二叉树的后序序列
void postorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left); // 先遍历左子树
    postorderTraversal(root->right); // 再遍历右子树
    printf("%d ", root->val); // 最后输出根结点
}

// 判断一棵二叉树是否是二叉搜索树
int isValidBST(TreeNode* root) {
    static TreeNode* prev = NULL; // 静态变量，记录前一个结点
    if (root == NULL) {
        return 1;
    }
    if (!isValidBST(root->left)) { // 遍历左子树
        return 0;
    }
    if (prev != NULL && prev->val >= root->val) { // 如果前一个结点的值大于等于当前结点的值，说明不是二叉搜索树
        return 0;
    }
    prev = root; // 更新前一个结点
    return isValidBST(root->right); // 遍历右子树
}

// 获取一棵二叉搜索树中的最小和最大关键字
void getMinMax(TreeNode* root, int* min, int* max) {
    if (root == NULL) {
        return;
    }
    if (root->val < *min) { // 如果当前结点的值比最小值还要小，更新最小值
        *min = root->val;
    }
    if (root->val > *max) { // 如果当前结点的值比最大值还要大，更新最大值
        *max = root->val;
    }
    getMinMax(root->left, min, max); // 遍历左子树
    getMinMax(root->right, min, max); // 遍历右子树
}

// 将二叉搜索树转换成排序的双向链表
TreeNode* convertBSTToList(TreeNode* root) {
    if (root == NULL) {
        return NULL;
    }
    TreeNode* left = convertBSTToList(root->left); // 转换左子树
    TreeNode* right = convertBSTToList(root->right); // 转换右子树
    if (left != NULL) { // 如果左子树不为空，将左子树的最右侧结点与当前结点相连
        TreeNode* node = left;
        while (node->right != NULL) {
            node = node->right;
        }
        node->right = root;
        root->left = node;
    }
    if (right != NULL) { // 如果右子树不为空，将右子树的最左侧结点与当前结点相连
        TreeNode* node = right;
        while (node->left != NULL) {
            node = node->left;
        }
        node->left = root;
        root->right = node;
    }
    return left != NULL ? left : root; // 返回链表的头结点
}

int main() {
    int n, i;
    printf("请输入结点个数：");
    scanf("%d", &n);
    int* preorder = (int*)malloc(n * sizeof(int));
    int* inorder = (int*)malloc(n * sizeof(int));
    printf("请输入前序序列：");
    for (i = 0; i < n; i++) {
        scanf("%d", &preorder[i]);
    }
    printf("请输入中序序列：");
    for (i = 0; i < n; i++) {
        scanf("%d", &inorder[i]);
    }
    TreeNode* root = buildTree(preorder, inorder, n, n);
    if (root == NULL) { // 如果构建失败，输出错误提示
        printf("输入的序列无法生成二叉树！\n");
        return 0;
    }
    printf("后序序列为：");
    postorderTraversal(root);
    printf("\n");
    if (isValidBST(root)) { // 判断是否是二叉搜索树
        printf("该二叉树是二叉搜索树！\n");
        int min = root->val, max = root->val;
        getMinMax(root, &min, &max); // 获取最小和最大关键字
        printf("最小关键字为：%d\n", min);
        printf("最大关键字为：%d\n", max);
        TreeNode* head = convertBSTToList(root); // 转换成排序的双向链表
        printf("链表中的结点为：");
        TreeNode* node = head;
        while (node != NULL) { // 遍历链表
            printf("%d ", node->val);
            node = node->right;
        }
        printf("\n");
    } else {
        printf("该二叉树不是二叉搜索树！\n");
    }
    return 0;
}