输入字符序列，建立并输出一棵二叉树，分别按先序，中序，后序遍历输出二叉树

这里提供一个基于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 build_tree(self, s):
        stack = []
        i = 0
        while i < len(s):
            if s[i] == '#':
                node = None
                if len(stack) > 0:
                    node = stack.pop()
                if len(stack) > 0:
                    parent = stack[-1]
                    if parent.left is None:
                        parent.left = node
                    else:
                        parent.right = node
                else:
                    self.root = node
            else:
                node = TreeNode(s[i])
                stack.append(node)
            i += 1

    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=' ')

# 测试代码
if __name__ == '__main__':
    s = 'ABD##E##CF##G##'
    tree = BinaryTree()
    tree.build_tree(s)

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

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

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

输入序列为一个字符串，其中每个节点用一个字母表示，空节点用字符'#'表示。例如，输入字符串'ABD##E##CF##G##'，表示的二叉树如下所示：

     A
    / \
   B   C
  /   / \
 D   F   G
  \      
   E     

输出先序遍历、中序遍历、后序遍历的结果分别为：

先序遍历：A B D E C F G 
中序遍历：D B E A F C G 
后序遍历：D E B F G C A 

这里采用了栈的数据结构来辅助建立二叉树，并实现了三种遍历方式的递归算法。