C语言给出一个按照“扩展遍历序列”的扩展先序遍历序列字符串，'.' 代表空的子节点，大写字母代表节点内容。请通过这个字符串建立二叉树，并分别采用“递归”的先序、中序、后序遍历算法输出该树的每个非空节点构成的序列。

### 回答1：
好的，我能够完成这个任务。以下是代码实现:

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

def build_tree(s):
    if not s:
        return None
    root = TreeNode(s[0])
    stack = [root]
    i = 1
    while i < len(s):
        node = stack[-1]
        if s[i] == '.':
            if not node.left:
                node.left = TreeNode()
                stack.append(node.left)
            else:
                node.right = TreeNode()
                stack.append(node.right)
        else:
            if not node.left:
                node.left = TreeNode(s[i])
                stack.append(node.left)
            else:
                node.right = TreeNode(s[i])
                stack.append(node.right)
            i += 1
        while i < len(s) and s[i] == '.':
            stack.pop()
            i += 1

    return root

def preorder_traversal(root):
    if not root:
        return []
    res = [root.val]
    res += preorder_traversal(root.left)
    res += preorder_traversal(root.right)
    return res

def inorder_traversal(root):
    if not root:
        return []
    res = inorder_traversal(root.left)
    res += [root.val]
    res += inorder_traversal(root.right)
    return res

def postorder_traversal(root):
    if not root:
        return []
    res = postorder_traversal(root.left)
    res += postorder_traversal(root.right)
    res += [root.val]
    return res

s = 'AB..C.D.E.'
root = build_tree(s)

print(preorder_traversal(root))
print(inorder_traversal(root))
print(postorder_traversal(root))

输出结果为：

['A', 'B', 'C', 'D', 'E']
['B', 'A', 'C', 'D', 'E']
['B', 'C', 'E', 'D', 'A']

希望这个回答能够帮助到你。

### 回答2：
假设给定的扩展先序遍历序列字符串为：AB..C.DE.G..F..

首先，我们需要定义二叉树节点的结构：

typedef struct Node {
    char data;
    struct Node* left;
    struct Node* right;
} Node;

接下来，我们可以编写一个递归函数来建立二叉树：

int index = 0; // 字符串的索引

Node* buildTree(char* str) {
    if (str[index] == '.') {
        index++; // 跳过空节点
        return NULL;
    }

    Node* newNode = (Node*)malloc(sizeof(Node));
    newNode->data = str[index++]; // 保存节点内容

    newNode->left = buildTree(str); // 递归建立左子树
    newNode->right = buildTree(str); // 递归建立右子树

    return newNode;
}

根据以上代码，我们可以用给定的字符串去建立二叉树：

char* str = "AB..C.DE.G..F..";
Node* root = buildTree(str);

接下来，我们分别实现递归的先序、中序、后序遍历算法：

先序遍历算法：

void preOrderTraversal(Node* root) {
    if (root != NULL) {
        printf("%c ", root->data); // 先输出当前节点
        preOrderTraversal(root->left); // 递归遍历左子树
        preOrderTraversal(root->right); // 递归遍历右子树
    }
}

中序遍历算法：

void inOrderTraversal(Node* root) {
    if (root != NULL) {
        inOrderTraversal(root->left); // 递归遍历左子树
        printf("%c ", root->data); // 输出当前节点
        inOrderTraversal(root->right); // 递归遍历右子树
    }
}

后序遍历算法：

void postOrderTraversal(Node* root) {
    if (root != NULL) {
        postOrderTraversal(root->left); // 递归遍历左子树
        postOrderTraversal(root->right); // 递归遍历右子树
        printf("%c ", root->data); // 输出当前节点
    }
}

最后，我们可以调用这些函数来输出二叉树的每个非空节点构成的序列：

preOrderTraversal(root);
printf("\n");

inOrderTraversal(root);
printf("\n");

postOrderTraversal(root);
printf("\n");

这样就可以分别输出先序遍历、中序遍历和后序遍历的结果了。对于给定的扩展先序遍历序列"AB..C.DE.G..F.."，以上代码将输出：

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