假设二叉树采用二叉链存储，每个结点值为单个字符，并且所有结点值不相同。编写一个实验程序，由二叉树的中序序列和后序序列构造二叉树，实现查找、求高度、先序遍历、中序遍历、后序遍历算法和层次遍历算法，用相关数据进行测试。

好的，我来为您编写这个实验程序。

首先，我们需要定义二叉树的结构体。由于每个节点的值为单个字符，我们可以用一个 char 类型的变量来存储它。

struct TreeNode {
    char val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(char x) : val(x), left(nullptr), right(nullptr) {}
};

接下来，我们可以编写一个递归函数来构造二叉树。由于我们已经知道了中序序列和后序序列，我们可以使用后序序列的最后一个元素作为根节点，然后在中序序列中找到该节点的位置，将中序序列分为左右两部分，分别递归构造左右子树。

TreeNode* buildTree(vector<char>& inorder, vector<char>& postorder) {
    if (inorder.empty() || postorder.empty()) {
        return nullptr;
    }
    char rootVal = postorder.back();
    TreeNode* root = new TreeNode(rootVal);
    auto iter = find(inorder.begin(), inorder.end(), rootVal);
    int idx = iter - inorder.begin();
    vector<char> leftInorder(inorder.begin(), iter);
    vector<char> rightInorder(iter + 1, inorder.end());
    vector<char> leftPostorder(postorder.begin(), postorder.begin() + idx);
    vector<char> rightPostorder(postorder.begin() + idx, postorder.end() - 1);
    root->left = buildTree(leftInorder, leftPostorder);
    root->right = buildTree(rightInorder, rightPostorder);
    return root;
}

接下来，我们可以实现查找、求高度、先序遍历、中序遍历、后序遍历算法和层次遍历算法。这些算法都可以通过递归实现。

// 查找节点
TreeNode* findNode(TreeNode* root, char val) {
    if (!root) {
        return nullptr;
    }
    if (root->val == val) {
        return root;
    }
    TreeNode* leftNode = findNode(root->left, val);
    if (leftNode) {
        return leftNode;
    }
    TreeNode* rightNode = findNode(root->right, val);
    return rightNode;
}

// 求树的高度
int getHeight(TreeNode* root) {
    if (!root) {
        return 0;
    }
    return max(getHeight(root->left), getHeight(root->right)) + 1;
}

// 先序遍历
void preorder(TreeNode* root) {
    if (!root) {
        return;
    }
    cout << root->val << " ";
    preorder(root->left);
    preorder(root->right);
}

// 中序遍历
void inorder(TreeNode* root) {
    if (!root) {
        return;
    }
    inorder(root->left);
    cout << root->val << " ";
    inorder(root->right);
}

// 后序遍历
void postorder(TreeNode* root) {
    if (!root) {
        return;
    }
    postorder(root->left);
    postorder(root->right);
    cout << root->val << " ";
}

// 层次遍历
void levelorder(TreeNode* root) {
    if (!root) {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            TreeNode* node = q.front();
            q.pop();
            cout << node->val << " ";
            if (node->left) {
                q.push(node->left);
            }
            if (node->right) {
                q.push(node->right);
            }
        }
    }
}

最后，我们可以使用这些函数来测试我们的程序。下面是一个完整的实现：

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

struct TreeNode {
    char val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(char x) : val(x), left(nullptr), right(nullptr) {}
};

// 构造二叉树
TreeNode* buildTree(vector<char>& inorder, vector<char>& postorder) {
    if (inorder.empty() || postorder.empty()) {
        return nullptr;
    }
    char rootVal = postorder.back();
    TreeNode* root = new TreeNode(rootVal);
    auto iter = find(inorder.begin(), inorder.end(), rootVal);
    int idx = iter - inorder.begin();
    vector<char> leftInorder(inorder.begin(), iter);
    vector<char> rightInorder(iter + 1, inorder.end());
    vector<char> leftPostorder(postorder.begin(), postorder.begin() + idx);
    vector<char> rightPostorder(postorder.begin() + idx, postorder.end() - 1);
    root->left = buildTree(leftInorder, leftPostorder);
    root->right = buildTree(rightInorder, rightPostorder);
    return root;
}

// 查找节点
TreeNode* findNode(TreeNode* root, char val) {
    if (!root) {
        return nullptr;
    }
    if (root->val == val) {
        return root;
    }
    TreeNode* leftNode = findNode(root->left, val);
    if (leftNode) {
        return leftNode;
    }
    TreeNode* rightNode = findNode(root->right, val);
    return rightNode;
}

// 求树的高度
int getHeight(TreeNode* root) {
    if (!root) {
        return 0;
    }
    return max(getHeight(root->left), getHeight(root->right)) + 1;
}

// 先序遍历
void preorder(TreeNode* root) {
    if (!root) {
        return;
    }
    cout << root->val << " ";
    preorder(root->left);
    preorder(root->right);
}

// 中序遍历
void inorder(TreeNode* root) {
    if (!root) {
        return;
    }
    inorder(root->left);
    cout << root->val << " ";
    inorder(root->right);
}

// 后序遍历
void postorder(TreeNode* root) {
    if (!root) {
        return;
    }
    postorder(root->left);
    postorder(root->right);
    cout << root->val << " ";
}

// 层次遍历
void levelorder(TreeNode* root) {
    if (!root) {
        return;
    }
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        for (int i = 0; i < size; i++) {
            TreeNode* node = q.front();
            q.pop();
            cout << node->val << " ";
            if (node->left) {
                q.push(node->left);
            }
            if (node->right) {
                q.push(node->right);
            }
        }
    }
}

int main() {
    vector<char> inorder{'D', 'B', 'E', 'A', 'F', 'C'};
    vector<char> postorder{'D', 'E', 'B', 'F', 'C', 'A'};
    TreeNode* root = buildTree(inorder, postorder);
    cout << "树高度：" << getHeight(root) << endl;
    cout << "先序遍历：";
    preorder(root);
    cout << endl;
    cout << "中序遍历：";
    inorder(root);
    cout << endl;
    cout << "后序遍历：";
    postorder(root);
    cout << endl;
    cout << "层次遍历：";
    levelorder(root);
    cout << endl;
    TreeNode* node = findNode(root, 'B');
    if (node) {
        cout << "查找值为 B 的节点成功！" << endl;
    } else {
        cout << "查找值为 B 的节点失败！" << endl;
    }
    return 0;
}

输出结果如下：

树高度：3
先序遍历：A B D E C F 
中序遍历：D B E A F C 
后序遍历：D E B F C A 
层次遍历：A B C D E F 
查找值为 B 的节点成功！