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

好的，我可以为您解答这个问题。

首先，我们需要先定义二叉树的节点，代码如下：

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

然后，我们可以按照如下方式构建二叉树：

# 构造二叉树
root = TreeNode('a')
root.left = TreeNode('b')
root.right = TreeNode('c')
root.left.left = TreeNode('d')
root.left.right = TreeNode('e')
root.right.left = TreeNode('f')
root.right.right = TreeNode('g')
root.left.left.left = TreeNode('h')
root.left.left.right = TreeNode('i')

接下来，我们可以依次实现先序遍历、中序遍历、后序遍历和层次遍历，并求解二叉树的高度和节点个数。

1. 先序遍历

先序遍历的顺序是：根节点 -> 左子树 -> 右子树。可以使用递归实现，代码如下：

def preorder_traversal(root):
    if not root:
        return
    print(root.val, end=' ')
    preorder_traversal(root.left)
    preorder_traversal(root.right)

2. 中序遍历

中序遍历的顺序是：左子树 -> 根节点 -> 右子树。同样可以使用递归实现，代码如下：

def inorder_traversal(root):
    if not root:
        return
    inorder_traversal(root.left)
    print(root.val, end=' ')
    inorder_traversal(root.right)

3. 后序遍历

后序遍历的顺序是：左子树 -> 右子树 -> 根节点。同样可以使用递归实现，代码如下：

def postorder_traversal(root):
    if not root:
        return
    postorder_traversal(root.left)
    postorder_traversal(root.right)
    print(root.val, end=' ')

4. 层次遍历

层次遍历需要用到队列来实现，代码如下：

from collections import deque

def level_order_traversal(root):
    if not root:
        return
    queue = deque()
    queue.append(root)
    while queue:
        node = queue.popleft()
        print(node.val, end=' ')
        if node.left:
            queue.append(node.left)
        if node.right:
            queue.append(node.right)

5. 求二叉树的高度

二叉树的高度可以使用递归实现，代码如下：

def get_height(root):
    if not root:
        return 0
    left_height = get_height(root.left)
    right_height = get_height(root.right)
    return max(left_height, right_height) + 1

6. 求二叉树的节点个数

二叉树的节点个数可以使用递归实现，代码如下：

def get_node_count(root):
    if not root:
        return 0
    left_node_count = get_node_count(root.left)
    right_node_count = get_node_count(root.right)
    return left_node_count + right_node_count + 1

最终，我们可以将以上函数依次调用，输出结果如下：

preorder_traversal(root)  # 输出：a b d h i e c f g
inorder_traversal(root)  # 输出：h d i b e a f c g
postorder_traversal(root)  # 输出：h i d e b f g c a
level_order_traversal(root)  # 输出：a b c d e f g h i
print(get_height(root))  # 输出：4
print(get_node_count(root))  # 输出：9

希望能对您有所帮助！