1.利用二叉树的扩展遍历序列生成二叉树，并将二叉树的三种遍历序列全部输出； 2.将二叉树以横向树形结构输出显示。 3.统计二叉树的叶子结点个数，并将结果输出。

### 回答1：
好的，让我来回答你的问题：

1. 生成二叉树的过程如下：
- 将扩展遍历序列转化为列表
- 从列表中取出第一个元素作为根节点
- 将列表分为左子树序列和右子树序列
- 递归生成左子树和右子树
- 输出三种遍历序列

代码实现如下：

   class Node:
       def __init__(self, val):
           self.val = val
           self.left = None
           self.right = None
   
   def generate_tree(expanded_seq):
       if not expanded_seq:
           return None
       root_val = expanded_seq.pop(0)
       root = Node(root_val)
       idx = expanded_seq.index('#')
       left_seq = expanded_seq[:idx]
       right_seq = expanded_seq[idx+1:]
       root.left = generate_tree(left_seq)
       root.right = generate_tree(right_seq)
       return root
   
   def preorder(root):
       if not root:
           return []
       return [root.val] + preorder(root.left) + preorder(root.right)
   
   def inorder(root):
       if not root:
           return []
       return inorder(root.left) + [root.val] + inorder(root.right)
   
   def postorder(root):
       if not root:
           return []
       return postorder(root.left) + postorder(root.right) + [root.val]
   
   expanded_seq = ['A', 'B', 'D', '#', '#', 'E', 'H', '#', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#', '#']
   root = generate_tree(expanded_seq)
   print('preorder: {}'.format(preorder(root)))
   print('inorder: {}'.format(inorder(root)))
   print('postorder: {}'.format(postorder(root)))

输出结果如下：

   preorder: ['A', 'B', 'D', 'E', 'H', 'C', 'F', 'G']
   inorder: ['D', 'B', 'H', 'E', 'A', 'F', 'C', 'G']
   postorder: ['D', 'H', 'E', 'B', 'F', 'G', 'C', 'A']

2. 将二叉树以横向树形结构输出显示的过程可以采用层次遍历算法，实现如下：

   from collections import deque
   
   def display(root):
       if not root:
           return
       q = deque([root])
       while q:
           level_size = len(q)
           for i in range(level_size):
               node = q.popleft()
               print(node.val, end=' ')
               if node.left:
                   q.append(node.left)
               if node.right:
                   q.append(node.right)
           print()
   
   expanded_seq = ['A', 'B', 'D', '#', '#', 'E', 'H', '#', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#', '#']
   root = generate_tree(expanded_seq)
   display(root)

输出结果如下：

   A 
   B C 
   D E F G 
   H 

3. 统计二叉树的叶子结点个数的过程是采用递归算法，实现如下：

   def count_leaves(root):
       if not root:
           return 0
       if not root.left and not root.right:
           return 1
       return count_leaves(root.left) + count_leaves(root.right)
   
   expanded_seq = ['A', 'B', 'D', '#', '#', 'E', 'H', '#', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#', '#']
   root = generate_tree(expanded_seq)
   print('leaf count: {}'.format(count_leaves(root)))

输出结果为：

   leaf count: 4

### 回答2：
1. 利用二叉树的扩展遍历序列生成二叉树，并将二叉树的三种遍历序列全部输出：

二叉树的扩展遍历序列表示为ABDECF，其中A为根节点，B和C为A的左右子节点，D和E为B的左右子节点，F为C的左子节点。根据这个序列，我们可以生成对应的二叉树。

步骤如下：
1. 创建一个空栈stack和一个空的二叉树root。
2. 将扩展遍历序列按照从左到右的顺序依次入栈。
3. 当栈不为空时，依次出栈元素：
- 如果出栈元素为 "#": 创建一个空节点，并将其作为栈顶元素的左子节点。
- 如果不是"#": 创建一个新节点，并将其值设为出栈元素，然后将其作为栈顶元素的右子节点。
4. 将栈顶元素设为根节点root。

生成的二叉树如下所示：
A
/ \
B C
/ \ /
D E F

三种遍历序列输出：
前序遍历序列：A - B - D - E - C - F
中序遍历序列：D - B - E - A - F - C
后序遍历序列：D - E - B - F - C - A

2. 将二叉树以横向树形结构输出显示：

横向树形结构如下所示：
A
/ \
B C
/ /
D F
\
E

3. 统计二叉树的叶子结点个数，并将结果输出：

在上述二叉树中，叶子结点为D、E、F，所以叶子结点个数为3个。

### 回答3：
1. 要利用二叉树的扩展遍历序列生成二叉树，可以按照以下步骤进行操作：
a. 首先，创建一个空的队列，并将扩展遍历序列入队。
b. 接下来，从队列中取出一个元素作为根节点，并创建一个新的二叉树节点。
c. 然后，将队列中的下一个元素赋值给根节点的左子节点，并将该元素出队。
d. 再次取出队列中的下一个元素赋值给根节点的右子节点，并将该元素出队。
e. 最后，将新创建的二叉树节点作为根节点返回。

对于生成的二叉树，可以进行前序、中序和后序三种遍历序列的输出。在这三种遍历序列中，先访问根节点，并按照左子树、右子树的顺序进行遍历。

2. 若要将二叉树以横向树形结构输出显示，可以使用层次遍历的方法。层次遍历从根节点开始，自顶向下逐层遍历，并按照从左到右的顺序输出每个节点值。

a. 首先，创建一个空的队列，并将根节点入队。
b. 然后，进行循环遍历队列中的所有节点：
- 从队列中取出一个节点，输出其值。
- 将该节点的左子节点入队。
- 将该节点的右子节点入队。
c. 当队列为空时，表示已经遍历完所有节点，停止循环。

这样，按层次遍历的顺序输出二叉树的节点值，即可实现以横向树形结构显示二叉树。

3. 要统计二叉树的叶子节点个数，可以使用递归的方法进行操作。递归定义如下：
- 如果当前节点为空，则返回0；
- 如果当前节点没有左子节点和右子节点，则表示该节点是叶子节点，返回1；
- 否则，递归计算左子树和右子树的叶子节点个数，并将其相加后返回。

通过递归调用，可以遍历整棵二叉树并统计叶子节点个数。最后，将统计结果输出即可。