结构体顺序存储方式：

#include <bits/stdc++.h>
using namespace std;
// 用于顺序存储的结点结构
struct Node {
    bool exist;  // true 表示该位置有结点，false 表示空('#')
    char val;    // 当 exist=true 时有效
};
// 递归检查从下标 i 开始的子树是否满足题目“对称”要求
bool isSymmetric(const vector<Node>& nodes, int i) {
    // 若该位置结点不存在，直接返回 true（空视为对称）
    if (i >= (int)nodes.size() || !nodes[i].exist) {
        return true;
    }
    // 计算左右子结点下标
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    // 判断左右子是否存在
    bool leftExist = (left < (int)nodes.size() && nodes[left].exist);
    bool rightExist = (right < (int)nodes.size() && nodes[right].exist);
    // 若左右均不存在，则此节点是叶子节点，对称
    if (!leftExist && !rightExist) {
        return true;
    }
    // 若仅有一个存在，则不对称
    if (leftExist != rightExist) {
        return false;
    }
    // 否则左右都存在，继续递归判断
    return isSymmetric(nodes, left) && isSymmetric(nodes, right);
}
int main() {
    // 读入字符串，例如 "ABCDE"、"ABCD#E" 等
    string s;
    cin >> s;
    // 若输入为空，认为对称（也可根据需求自行处理）
    if (s.empty()) {
        cout << "Yes" << endl;
        return 0;
    }
    // 用一个 vector<Node> 存储顺序结构
    vector<Node> nodes(s.size());
    // 初始化每个位置的结点（或标记为空）
    for (int i = 0; i < (int)s.size(); i++) {
        if (s[i] == '#') {
            // 空节点
            nodes[i].exist = false;
        } else {
            // 有效节点
            nodes[i].exist = true;
            nodes[i].val = s[i];
        }
    }
    // 判断根节点是否存在
    // 若根节点都不存在，那就是一棵空树，视为对称
    if (!nodes[0].exist) {
        cout << "Yes" << endl;
        return 0;
    }
    // 调用递归函数，判断整棵树是否对称
    if (isSymmetric(nodes, 0)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }
    return 0;
}

结构体指针方法：

#include <bits/stdc++.h>
using namespace std;
// 二叉树的结点定义
struct Node {
    char val;
    Node* left;
    Node* right;
    Node(char c) : val(c), left(nullptr), right(nullptr) {}
};
// 递归判断二叉树是否符合题目“对称”定义
bool isSymmetric(Node* root) {
    if (!root) {
        // 空节点，符合对称要求
        return true;
    }
    // 如果左右子树都为空，也符合对称要求
    if (!root->left && !root->right) {
        return true;
    }
    // 如果左右子树只有一个为空，则不对称
    if (!root->left || !root->right) {
        return false;
    }
    // 继续递归判断左右子树
    return isSymmetric(root->left) && isSymmetric(root->right);
}

int main() {
    // 读入字符串，比如 "ABCDE" 或 "ABCD#E" 等
    string s;
    cin >> s;

    // 若输入为空，直接判断为对称 (也可视需求而定)
    if (s.empty()) {
        cout << "Yes" << endl;
        return 0;
    }

    // 第一步：先根据输入，创建结点指针数组
    //   - 若字符是 '#', 则该位置对应空指针
    //   - 否则创建一个节点
    int n = s.size();
    vector<Node*> nodes(n, nullptr);
    for (int i = 0; i < n; i++) {
        if (s[i] != '#') {
            nodes[i] = new Node(s[i]);
        }
    }

    // 第二步：把这些节点按照层序链接起来
    //   下标 i 的左子节点是 2*i+1, 右子节点是 2*i+2
    for (int i = 0; i < n; i++) {
        if (nodes[i] != nullptr) {
            int leftIdx = 2 * i + 1;
            int rightIdx = 2 * i + 2;
            if (leftIdx < n) {
                nodes[i]->left = nodes[leftIdx];
            }
            if (rightIdx < n) {
                nodes[i]->right = nodes[rightIdx];
            }
        }
    }

    // 第三步：递归判断根节点是否满足“对称”要求
    // 根节点是 nodes[0]（不为空时）
    Node* root = nodes[0];
    if (isSymmetric(root)) {
        cout << "Yes" << endl;
    } else {
        cout << "No" << endl;
    }

    // 程序结束，简单起见，不做内存释放处理
    return 0;
}

非递归方法：

#include <bits/stdc++.h>
using namespace std;
string str;
int main()
{
    cin>>str;
    int len=str.size();
    str[len]='#';

    int flag=true;
    for(int i=1;i<len;i+=2)
        if( (str[i]=='#'&&str[i+1]!='#') || (str[i+1]=='#'&&str[i]!='#') )
        {
            flag=false;
            break;
        }
    if(flag)
        cout<<"Yes"<<endl;
    else
        cout<<"No"<<endl;
    return 0;
}