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

好的，以下是该二叉树的构造、遍历和统计的Python代码：

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

class BiTree:
    def __init__(self):
        self.root = None
    
    def create(self, data):
        if not data:
            return None
        
        queue = []
        for val in data:
            node = TreeNode(val)
            if self.root is None:
                self.root = node
            else:
                parent = queue[0]
                if parent.left is None:
                    parent.left = node
                else:
                    parent.right = node
                    queue.pop(0)
                queue.append(node)
        return self.root
    
    def preorder_traversal(self, root):
        if root is None:
            return
        print(root.val, end=" ")
        self.preorder_traversal(root.left)
        self.preorder_traversal(root.right)
    
    def inorder_traversal(self, root):
        if root is None:
            return
        self.inorder_traversal(root.left)
        print(root.val, end=" ")
        self.inorder_traversal(root.right)
    
    def postorder_traversal(self, root):
        if root is None:
            return
        self.postorder_traversal(root.left)
        self.postorder_traversal(root.right)
        print(root.val, end=" ")
    
    def level_traversal(self, root):
        if root is None:
            return
        
        queue = [root]
        while queue:
            node = queue.pop(0)
            print(node.val, end=" ")
            if node.left:
                queue.append(node.left)
            if node.right:
                queue.append(node.right)
    
    def height(self, root):
        if root is None:
            return 0
        left_height = self.height(root.left)
        right_height = self.height(root.right)
        return max(left_height, right_height) + 1
    
    def count_nodes(self, root):
        if root is None:
            return 0
        left_count = self.count_nodes(root.left)
        right_count = self.count_nodes(root.right)
        return left_count + right_count + 1

# 测试
data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i']
tree = BiTree()
root = tree.create(data)

print("先序遍历：", end="")
tree.preorder_traversal(root)
print()

print("中序遍历：", end="")
tree.inorder_traversal(root)
print()

print("后序遍历：", end="")
tree.postorder_traversal(root)
print()

print("层次遍历：", end="")
tree.level_traversal(root)
print()

print("二叉树高度：", tree.height(root))
print("二叉树节点个数：", tree.count_nodes(root))

在上述代码中，我们首先定义了 `TreeNode` 类来表示二叉树的节点，其中包含了节点的值 `val`、左子节点 `left` 和右子节点 `right`。

接着，我们定义了 `BiTree` 类来表示二叉树，其中包含了二叉树的根节点 `root` 及相关操作。在 `create` 方法中，我们按照题目给定的元素顺序依次插入节点，使用一个队列 `queue` 来辅助插入操作。在插入时，我们首先创建一个新节点 `node`，然后判断是否为根节点。如果是根节点，直接将其设置为根节点；否则，从队列中取出一个节点 `parent`，将新节点插入到其左右子节点中的空位上，并将新节点加入队列中。最后，该方法返回根节点。

接下来，我们定义了 `preorder_traversal`、`inorder_traversal`、`postorder_traversal` 和 `level_traversal` 方法来实现先序遍历、中序遍历、后序遍历和层次遍历。其中，先序遍历、中序遍历和后序遍历均为递归实现，而层次遍历则使用一个队列来实现。在输出节点值时，我们使用 `end` 参数将输出的字符串结尾设置为空格，以便在一行输出所有节点。

最后，我们定义了 `height` 和 `count_nodes` 方法来统计二叉树的高度和节点个数。其中，二叉树的高度定义为从根节点到叶子节点的最长路径长度，节点的个数定义为二叉树中节点的总数。这两个方法均使用递归实现。

在测试代码中，我们首先按照题目给定的元素顺序构造了一个二叉树，并将其根节点存储到变量 `root` 中。然后，依次调用 `preorder_traversal`、`inorder_traversal`、`postorder_traversal` 和 `level_traversal` 方法，输出不同遍历方式的节点值。接着，我们分别调用 `height` 和 `count_nodes` 方法，输出二叉树的高度和节点个数。