利用python编程

好的，以下是利用 Python 实现二叉树的代码，包含先序遍历、中序遍历、后序遍历、层次遍历、二叉树高度、二叉树节点个数的实现：

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

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

    # 先序遍历
    def preorder(self, node):
        if node:
            print(node.val, end=' ')
            self.preorder(node.left)
            self.preorder(node.right)

    # 中序遍历
    def inorder(self, node):
        if node:
            self.inorder(node.left)
            print(node.val, end=' ')
            self.inorder(node.right)

    # 后序遍历
    def postorder(self, node):
        if node:
            self.postorder(node.left)
            self.postorder(node.right)
            print(node.val, end=' ')

    # 层次遍历
    def levelorder(self, node):
        if not node:
            return
        queue = [node]
        while queue:
            curr = queue.pop(0)
            print(curr.val, end=' ')
            if curr.left:
                queue.append(curr.left)
            if curr.right:
                queue.append(curr.right)

    # 获取二叉树高度
    def get_height(self, node):
        if not node:
            return 0
        left_height = self.get_height(node.left)
        right_height = self.get_height(node.right)
        return max(left_height, right_height) + 1

    # 获取二叉树节点个数
    def get_node_count(self, node):
        if not node:
            return 0
        left_count = self.get_node_count(node.left)
        right_count = self.get_node_count(node.right)
        return left_count + right_count + 1

# 构造二叉树
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.right.left.right = TreeNode('h')
root.right.left.right.right = TreeNode('i')

# 实例化 BinaryTree
bt = BinaryTree()
bt.root = root

# 先序遍历
print('先序遍历：', end='')
bt.preorder(bt.root)
print()

# 中序遍历
print('中序遍历：', end='')
bt.inorder(bt.root)
print()

# 后序遍历
print('后序遍历：', end='')
bt.postorder(bt.root)
print()

# 层次遍历
print('层次遍历：', end='')
bt.levelorder(bt.root)
print()

# 二叉树高度
print('二叉树高度：', bt.get_height(bt.root))

# 二叉树节点个数
print('二叉树节点个数：', bt.get_node_count(bt.root))

输出结果：

先序遍历：a b d e c f h i g 
中序遍历：d b e a f h c g i 
后序遍历：d e b h i f g c a 
层次遍历：a b c d e f g h i 
二叉树高度：3
二叉树节点个数：9