题解 | #牛群的轴对称结构#

定义一个带索引的向量，每次递归都将树结构下一层的节点加入向量中，对于每一层，依据索引判断是否是对应的两个节点，然后判断对应的两个节点的值是否相同，如果不符合条件，则不是轴对称结构，整棵树检索完毕后，即为轴对称结构。

/**
 * struct TreeNode {
 *	int val;
 *	struct TreeNode *left;
 *	struct TreeNode *right;
 *	TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 * };
 */
class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    bool isSymmetric(TreeNode* root) {
        vector<pair<int, TreeNode*>> layer_prev;
        layer_prev.push_back({0, root});
        return judgeSymmetric(layer_prev);
    }

    bool judgeSymmetric(vector<pair<int, TreeNode*>> & layer_prev) {
        if (layer_prev.size() == 0) {
            return true;
        }
        vector<pair<int, TreeNode*>> layer;
        int index = 0;
        for (pair<int, TreeNode*> element : layer_prev) {
            if (element.second->left != nullptr) {
                layer.push_back({index, element.second->left});
            }
            if (element.second->right != nullptr) {
                layer.push_back({index + 1, element.second->right});
            }
            index += 2;
        }
        layer_prev.clear();
        for (pair<int, TreeNode*> element : layer) {
            layer_prev.push_back(element);
        }
        if (layer.size() % 2 != 0) {
            return false;
        }
        for (int i = 0; i < layer.size() / 2; i++) {
            if (layer.at(i).first + layer.at(layer.size() - i - 1).first != index - 1 || layer.at(i).second->val != layer.at(layer.size() - i - 1).second->val) {
                return false;
            }
        }
        return judgeSymmetric(layer_prev);
    }
};