### 思路

1. **输入读取**：
   - 读取输入字符串，表示完全二叉树的顺序存储结构。

2. **构建二叉树**：
   - 使用队列构建二叉树，按层次顺序插入节点。

3. **之字形层序遍历**：
   - 使用双端队列进行层序遍历，交替从左到右和从右到左。

4. **输出结果**：
   - 按层输出节点值。

### 伪代码

1. 读取输入字符串 `input`。
2. 定义 `TreeNode` 结构体，包含 `val`，`left` 和 `right`。
3. 构建二叉树：
   - 初始化队列 `q`。
   - 创建根节点并入队。
   - 遍历 `input`，按层次顺序插入节点。
4. 之字形层序遍历：
   - 初始化双端队列 `dq`。
   - 初始化结果列表 `result`。
   - 使用标志变量 `left_to_right` 控制遍历方向。
   - 遍历每一层节点，按 `left_to_right` 方向插入 `dq`。
   - 将 `dq` 中的节点值加入 `result`。
5. 输出 `result`。

### C++代码

#include <iostream>
#include <vector>
#include <deque>
#include <queue>

struct TreeNode {
    char val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(char x) : val(x), left(NULL), right(NULL) {}
};

TreeNode* buildTree(const std::string& input) {
    if (input.empty() || input[0] == '#') return nullptr;
    TreeNode* root = new TreeNode(input[0]);
    std::queue<TreeNode*> q;
    q.push(root);
    int i = 1;
    while (!q.empty() && i < input.size()) {
        TreeNode* node = q.front();
        q.pop();
        if (input[i] != '#') {
            node->left = new TreeNode(input[i]);
            q.push(node->left);
        }
        i++;
        if (i < input.size() && input[i] != '#') {
            node->right = new TreeNode(input[i]);
            q.push(node->right);
        }
        i++;
    }
    return root;
}

void zigzagLevelOrder(TreeNode* root) {
    if (!root) return;
    std::deque<TreeNode*> dq;
    dq.push_back(root);
    bool left_to_right = true;
    while (!dq.empty()) {
        int size = dq.size();
        std::vector<char> level;
        for (int i = 0; i < size; ++i) {
            if (left_to_right) {
                TreeNode* node = dq.front();
                dq.pop_front();
                level.push_back(node->val);
                if (node->left) dq.push_back(node->left);
                if (node->right) dq.push_back(node->right);
            } else {
                TreeNode* node = dq.back();
                dq.pop_back();
                level.push_back(node->val);
                if (node->right) dq.push_front(node->right);
                if (node->left) dq.push_front(node->left);
            }
        }
        for (char c : level) {
            std::cout << c << " ";
        }
        std::cout << std::endl;
        left_to_right = !left_to_right;
    }
}

int main() {
    std::string input;
    std::cin >> input;
    TreeNode* root = buildTree(input);
    zigzagLevelOrder(root);
    return 0;
}