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

好的，这是一个比较复杂的程序，需要一步步构建。我先给您提供一个框架，您可以根据需要进行修改和补充。

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

class BinaryTree:
    def __init__(self, inorder, postorder):
        self.root = self.build_tree(inorder, postorder)

    def build_tree(self, inorder, postorder):
        if not inorder or not postorder:
            return None

        root = Node(postorder[-1])
        root_index = inorder.index(root.value)

        root.left = self.build_tree(inorder[:root_index], postorder[:root_index])
        root.right = self.build_tree(inorder[root_index+1:], postorder[root_index:-1])

        return root

    def search(self, value):
        pass

    def height(self):
        pass

    def preorder(self, node):
        pass

    def inorder(self, node):
        pass

    def postorder(self, node):
        pass

    def levelorder(self, node):
        pass

其中，`Node` 类表示二叉树的结点，包含一个值和左右子节点。`BinaryTree` 类表示二叉树，包含根节点和各种方法。在构造函数中，我们根据中序序列和后序序列构建二叉树。在 `build_tree` 方法中，我们首先判断序列是否为空，如果为空则返回 `None`。否则，我们取后序序列的最后一个元素作为根节点，找到它在中序序列中的位置，然后将中序序列分为左右两个部分，分别递归构建左右子树。最终返回根节点。

接下来，我们需要补全其他方法的代码：

class BinaryTree:
    ...

    def search(self, value):
        def dfs(node):
            if not node:
                return None
            if node.value == value:
                return node
            left = dfs(node.left)
            if left:
                return left
            right = dfs(node.right)
            if right:
                return right
            return None
        
        return dfs(self.root)

    def height(self):
        def dfs(node):
            if not node:
                return 0
            return max(dfs(node.left), dfs(node.right)) + 1
        
        return dfs(self.root)

    def preorder(self, node):
        if not node:
            return []
        return [node.value] + self.preorder(node.left) + self.preorder(node.right)

    def inorder(self, node):
        if not node:
            return []
        return self.inorder(node.left) + [node.value] + self.inorder(node.right)

    def postorder(self, node):
        if not node:
            return []
        return self.postorder(node.left) + self.postorder(node.right) + [node.value]

    def levelorder(self, node):
        if not node:
            return []
        queue = [node]
        res = []
        while queue:
            cur = queue.pop(0)
            res.append(cur.value)
            if cur.left:
                queue.append(cur.left)
            if cur.right:
                queue.append(cur.right)
        return res

在 `search` 方法中，我们采用深度优先搜索（DFS）的方式查找指定值的结点。在 `height` 方法中，我们同样采用 DFS 的方式计算树的高度。在 `preorder`、`inorder` 和 `postorder` 方法中，分别实现了先序、中序和后序遍历。在 `levelorder` 方法中，我们采用广度优先搜索（BFS）的方式实现层次遍历。

最后，我们可以用以下方式测试程序：

inorder = ['D', 'B', 'E', 'A', 'F', 'C']
postorder = ['D', 'E', 'B', 'F', 'C', 'A']
tree = BinaryTree(inorder, postorder)

assert tree.search('A').value == 'A'
assert tree.search('X') == None
assert tree.height() == 3
assert tree.preorder(tree.root) == ['A', 'B', 'D', 'E', 'C', 'F']
assert tree.inorder(tree.root) == ['D', 'B', 'E', 'A', 'F', 'C']
assert tree.postorder(tree.root) == ['D', 'E', 'B', 'F', 'C', 'A']
assert tree.levelorder(tree.root) == ['A', 'B', 'C', 'D', 'E', 'F']

这里我们构建了一个二叉树，测试了各种方法的正确性。您可以根据需要修改测试用例。