C语言以扩展先序遍历序列建立一个二叉树，并将该二叉树中序线索化，输入一个节点，输出在该中序线索二叉树中，该节点的直接前驱及直接后继节点,第一行为扩展先序遍历序列,第二行为待查找的节点,如果该节点有直接前驱，则输出该节点的直接前驱的数据域；若无，则输出NULL,如果该节点有直接后继，则输出该节点的直接后继的数据域；若无，则输出NULL

以下是代码实现：

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

// 二叉树结构体
typedef struct TreeNode {
    int val;
    struct TreeNode* left;
    struct TreeNode* right;
    int ltag;
    int rtag;
} TreeNode;

// 创建二叉树
TreeNode* createTree(int* preorder, int* index) {
    int val = preorder[*index];
    *index += 1;
    if (val == -1) {
        return NULL;
    }
    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
    root->val = val;
    root->left = createTree(preorder, index);
    root->right = createTree(preorder, index);

    return root;
}

// 中序线索化
TreeNode* inOrderThreading(TreeNode* root, TreeNode* pre) {
    if (!root) {
        return NULL;
    }

    TreeNode* left = inOrderThreading(root->left, pre);
    if (!left) {
        root->ltag = 1;
        root->left = pre;
    }

    if (pre && !pre->right) {
        pre->rtag = 1;
        pre->right = root;
    }

    pre = root;
    TreeNode* right = inOrderThreading(root->right, pre);
    if (!right) {
        root->rtag = 1;
    }

    return right ? right : root;
}

// 查找节点
TreeNode* findNode(TreeNode* root, int val) {
    while (root) {
        if (root->val == val) {
            return root;
        } else if (root->val > val) {
            if (root->ltag) {
                return NULL;
            } else {
                root = root->left;
            }
        } else {
            if (root->rtag) {
                return NULL;
            } else {
                root = root->right;
            }
        }
    }

    return NULL;
}

// 查找节点的前驱
TreeNode* findPredecessor(TreeNode* node) {
    if (node->ltag) {
        return node->left;
    }

    TreeNode* cur = node->left;
    while (cur && !cur->rtag) {
        cur = cur->right;
    }

    return cur;
}

// 查找节点的后继
TreeNode* findSuccessor(TreeNode* node) {
    if (node->rtag) {
        return node->right;
    }

    TreeNode* cur = node->right;
    while (cur && !cur->ltag) {
        cur = cur->left;
    }

    return cur;
}

int main() {
    int preorder[] = {1, 2, 4, -1, -1, 5, -1, -1, 3, 6, -1, -1, 7, -1, -1};
    TreeNode* root = createTree(preorder, &(int){0});
    TreeNode* pre = NULL;
    inOrderThreading(root, pre);

    int val;
    printf("请输入一个节点：");
    scanf("%d", &val);
    TreeNode* node = findNode(root, val);

    if (!node) {
        printf("NULL\n");
    } else {
        TreeNode* pred = findPredecessor(node);
        TreeNode* succ = findSuccessor(node);
        if (pred) {
            printf("前驱：%d\n", pred->val);
        } else {
            printf("前驱：NULL\n");
        }
        if (succ) {
            printf("后继：%d\n", succ->val);
        } else {
            printf("后继：NULL\n");
        }
    }

    return 0;
}

代码思路：

1. 先根据扩展先序遍历序列构建二叉树。
2. 对该二叉树进行中序线索化。
3. 根据输入的节点值，查找该节点在中序线索二叉树中的位置。
4. 如果该节点不存在，则输出 NULL。
5. 如果该节点存在，则分别查找该节点的前驱和后继。
6. 如果该节点存在前驱，则输出前驱的值；否则输出 NULL。
7. 如果该节点存在后继，则输出后继的值；否则输出 NULL。