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

以下是一个简单的实现：

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

typedef struct node {
    int value;
    struct node *left;
    struct node *right;
} Node;

Node *build_tree(int *preorder, int *inorder, int len) {
    if (len == 0) {
        return NULL;
    }
    int root_value = *preorder;
    int i;
    for (i = 0; i < len; i++) {
        if (*(inorder + i) == root_value) {
            break;
        }
    }
    if (i == len) {
        printf("Invalid input!\n");
        return NULL;
    }
    Node *root = (Node *) malloc(sizeof(Node));
    root->value = root_value;
    root->left = build_tree(preorder + 1, inorder, i);
    root->right = build_tree(preorder + 1 + i, inorder + i + 1, len - i - 1);
    return root;
}

void print_postorder(Node *root) {
    if (root == NULL) {
        return;
    }
    print_postorder(root->left);
    print_postorder(root->right);
    printf("%d ", root->value);
}

int is_bst_helper(Node *root, int min, int max) {
    if (root == NULL) {
        return 1;
    }
    if (root->value < min || root->value > max) {
        return 0;
    }
    return is_bst_helper(root->left, min, root->value - 1) &&
           is_bst_helper(root->right, root->value + 1, max);
}

int is_bst(Node *root) {
    return is_bst_helper(root, -2147483648, 2147483647);
}

void get_min_max(Node *root, int *min, int *max) {
    if (root == NULL) {
        return;
    }
    if (root->value < *min) {
        *min = root->value;
    }
    if (root->value > *max) {
        *max = root->value;
    }
    get_min_max(root->left, min, max);
    get_min_max(root->right, min, max);
}

void convert_to_list_helper(Node *root, Node **prev) {
    if (root == NULL) {
        return;
    }
    convert_to_list_helper(root->left, prev);
    root->left = *prev;
    if (*prev != NULL) {
        (*prev)->right = root;
    }
    *prev = root;
    convert_to_list_helper(root->right, prev);
}

Node *convert_to_list(Node *root) {
    Node *prev = NULL;
    convert_to_list_helper(root, &prev);
    while (root != NULL && root->left != NULL) {
        root = root->left;
    }
    return root;
}

int main() {
    int n;
    printf("Enter the number of nodes: ");
    scanf("%d", &n);

    int *preorder = (int *) malloc(n * sizeof(int));
    int *inorder = (int *) malloc(n * sizeof(int));

    printf("Enter the preorder sequence: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", preorder + i);
    }

    printf("Enter the inorder sequence: ");
    for (int i = 0; i < n; i++) {
        scanf("%d", inorder + i);
    }

    Node *root = build_tree(preorder, inorder, n);
    if (root != NULL) {
        printf("Postorder sequence: ");
        print_postorder(root);
        printf("\n");

        if (is_bst(root)) {
            int min = 2147483647;
            int max = -2147483648;
            get_min_max(root, &min, &max);
            printf("Minimum value: %d\n", min);
            printf("Maximum value: %d\n", max);

            Node *list_root = convert_to_list(root);
            printf("Sorted list: ");
            while (list_root != NULL) {
                printf("%d ", list_root->value);
                list_root = list_root->right;
            }
            printf("\n");
        } else {
            printf("The tree is not a binary search tree!\n");
        }
    }

    free(preorder);
    free(inorder);
    return 0;
}

该程序首先要求用户输入前序和中序遍历序列，然后构建一棵二叉树，并打印其后序遍历序列。如果输入的序列无法构建一棵二叉树，则程序会输出错误提示。

接下来，程序会判断该二叉树是否是二叉搜索树。如果是，程序会输出该树的最小和最大关键字，并将该树转换成一个排序的双向链表。

注意，该程序中的二叉树节点结构体包括一个整数值，以及左右子树指针。`build_tree()` 函数通过递归地构建左右子树来构建整棵二叉树。`print_postorder()` 函数通过递归地遍历左右子树来打印二叉树的后序遍历序列。

`is_bst_helper()` 函数是一个递归函数，用于判断一个二叉树是否是二叉搜索树。该函数使用 `min` 和 `max` 参数来维护当前节点值必须满足的最小和最大值。`is_bst()` 函数是一个简单的包装函数，用于调用 `is_bst_helper()` 函数。

`get_min_max()` 函数使用递归来找到二叉搜索树中的最小和最大关键字。`convert_to_list_helper()` 函数通过递归地遍历二叉树来将其转换成一个排序的双向链表。`convert_to_list()` 函数是一个简单的包装函数，用于调用 `convert_to_list_helper()` 函数。