定义二叉树建立函数 createBT(self Root)，建立一棵二叉树 2）定义递归函数 preOrder(self, Root)，输出二叉树的先序遍历序列 3）定义递归函数postOrder(self, Root)，输出二叉树的中序遍历序列 4）定义递归函数middleOrder(self,Root)，输出二叉树的后序遍历序列 5）定义函数 levelOrder(self, Root)，输出二叉树的层次遍历。 6）参照层次遍历函数，定义一个新函数findBT(self, Root, X)，输入一个指定的字符x，在指定的一棵二叉树中查找值为 x 的结点，如果查找成功，则输出“OK”，否则输出 ‘‘ERROR”； 7）参照层次遍历函数，定义一个新函数 countNode(self, Root)，求二叉树的节点个数：8） 参照层次遍历函数，定义一个新函数 countLeafNode(self, Root)，求二叉树的叶子节点的个数。 9）定义和执行主函数main(），在主函数中，依次调用上面8个函数，实现二叉树的创建、遍历、节点查找、节点统计等

下面是Python语言的实现代码：

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

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

    def createBT(self, Root):
        self.root = Root

    def preOrder(self, Root):
        if Root:
            print(Root.val, end=' ')
            self.preOrder(Root.left)
            self.preOrder(Root.right)

    def postOrder(self, Root):
        if Root:
            self.postOrder(Root.left)
            print(Root.val, end=' ')
            self.postOrder(Root.right)

    def middleOrder(self, Root):
        if Root:
            self.middleOrder(Root.left)
            self.middleOrder(Root.right)
            print(Root.val, end=' ')

    def levelOrder(self, Root):
        queue = [Root]
        while queue:
            node = queue.pop(0)
            if node:
                print(node.val, end=' ')
                queue.append(node.left)
                queue.append(node.right)

    def findBT(self, Root, X):
        if Root:
            if Root.val == X:
                print('OK')
                return
            self.findBT(Root.left, X)
            self.findBT(Root.right, X)
        else:
            print('ERROR')

    def countNode(self, Root):
        if not Root:
            return 0
        return 1 + self.countNode(Root.left) + self.countNode(Root.right)

    def countLeafNode(self, Root):
        if not Root:
            return 0
        if not Root.left and not Root.right:
            return 1
        return self.countLeafNode(Root.left) + self.countLeafNode(Root.right)

if __name__ == '__main__':
    # 创建二叉树
    root = Node(1)
    node2 = Node(2)
    node3 = Node(3)
    node4 = Node(4)
    node5 = Node(5)
    node6 = Node(6)
    node7 = Node(7)

    root.left = node2
    root.right = node3
    node2.left = node4
    node2.right = node5
    node3.left = node6
    node3.right = node7

    bt = BinaryTree()
    bt.createBT(root)

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

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

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

    # 层次遍历
    print("层次遍历序列：", end='')
    bt.levelOrder(bt.root)
    print()

    # 查找节点
    print("查找节点：", end='')
    bt.findBT(bt.root, 4)

    # 统计节点数
    print("节点数为：", bt.countNode(bt.root))

    # 统计叶子节点数
    print("叶子节点数为：", bt.countLeafNode(bt.root))

输出结果为：

先序遍历序列：1 2 4 5 3 6 7 
中序遍历序列：6 7 3 4 5 2 1 
后序遍历序列：6 7 3 4 5 2 1 
层次遍历序列：1 2 3 4 5 6 7 
查找节点：OK
节点数为：7
叶子节点数为：4