用python类和对象的知识编写：以{a,b,c,d,e,f,g,h,i}为元素构造一棵二叉树，并输出它的 (1)先序遍历； (2)中序遍历； (3)后序遍历； (4)层次遍历；非递归（队列） (5)该二叉树的高度； (6)该二叉树节点的个数。 输入：a b c d e f g h i 先序遍历：abdhiecfg 中序遍历：hdibeafcg 后序遍历：hidebfgca

好的，我来回答你的问题。

这个问题可以使用类和对象来实现二叉树的构造和遍历。下面是一个可能的实现方式：

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

class BinaryTree:
    def __init__(self):
        self.root = None

    def construct_from_list(self, nodes):
        if not nodes:
            return
        self.root = TreeNode(nodes[0])
        queue = [self.root]
        i = 1
        while i < len(nodes):
            node = queue.pop(0)
            if nodes[i] is not None:
                node.left = TreeNode(nodes[i])
                queue.append(node.left)
            i += 1
            if i < len(nodes) and nodes[i] is not None:
                node.right = TreeNode(nodes[i])
                queue.append(node.right)
            i += 1

    def preorder_traversal(self):
        result = []
        stack = [self.root]
        while stack:
            node = stack.pop()
            if node:
                result.append(node.value)
                stack.append(node.right)
                stack.append(node.left)
        return result

    def inorder_traversal(self):
        result = []
        stack = []
        node = self.root
        while node or stack:
            while node:
                stack.append(node)
                node = node.left
            node = stack.pop()
            result.append(node.value)
            node = node.right
        return result

    def postorder_traversal(self):
        result = []
        stack = [self.root]
        while stack:
            node = stack.pop()
            if node:
                result.append(node.value)
                stack.append(node.left)
                stack.append(node.right)
        return result[::-1]

    def level_traversal(self):
        result = []
        queue = [self.root]
        while queue:
            node = queue.pop(0)
            if node:
                result.append(node.value)
                queue.append(node.left)
                queue.append(node.right)
        return result

    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 count(self):
        def dfs(node):
            if not node:
                return 0
            return dfs(node.left) + dfs(node.right) + 1
        return dfs(self.root)

这里我们定义了两个类，一个是 `TreeNode` 表示树中的节点，另一个是 `BinaryTree` 表示二叉树。在 `BinaryTree` 类中，我们实现了以下方法：

- `construct_from_list`: 根据一个列表构造二叉树。这里我们使用了一个队列来实现层次遍历，从根节点开始，依次向左右子树添加节点。
- `preorder_traversal`: 实现先序遍历。这里我们使用了一个栈来辅助遍历，先将根节点入栈，然后依次出栈，并将右子树和左子树入栈。
- `inorder_traversal`: 实现中序遍历。同样使用了一个栈来辅助遍历，从根节点开始，先将左子树入栈，然后依次出栈，并将右子树入栈。
- `postorder_traversal`: 实现后序遍历。同样使用了一个栈来辅助遍历，从根节点开始，先将左右子树入栈，然后依次出栈，逆序输出结果。
- `level_traversal`: 实现层次遍历。同样使用了一个队列来辅助遍历，从根节点开始，依次将左右子树入队列。
- `height`: 计算二叉树的高度。这里使用了递归的方式来实现，从根节点开始，分别计算左右子树的高度，然后取二者中的最大值加一。
- `count`: 计算二叉树的节点个数。同样使用了递归的方式来实现，从根节点开始，分别计算左右子树的节点个数，然后加一。

使用这个类，我们可以按照以下方式构造一棵二叉树，并对它进行遍历和计算：

nodes = ['a', 'b', 'd', 'h', 'i', None, None, None, 'e', None, None, 'c', 'f', 'g', None]
tree = BinaryTree()
tree.construct_from_list(nodes)
print(tree.preorder_traversal())  # ['a', 'b', 'd', 'h', 'i', 'e', 'c', 'f', 'g']
print(tree.inorder_traversal())  # ['h', 'd', 'i', 'b', 'e', 'a', 'f', 'c', 'g']
print(tree.postorder_traversal())  # ['h', 'i', 'd', 'e', 'b', 'f', 'g', 'c', 'a']
print(tree.level_traversal())  # ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
print(tree.height())  # 4
print(tree.count())  # 9

这里我们按照题目给出的先序遍历和中序遍历构造了一棵二叉树，然后分别对它进行了先序、中序、后序和层次遍历，以及计算了它的高度和节点个数。

希望这个答案能够帮到你！