day29

【0101.对称二叉树】

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<int> preOrder(TreeNode* root) {
        vector<int> result;
        while (root != NULL) {
            result.push_back(root->val);
            if (root->left)     preOrder(root->left);
            if (root->right)    postOrder(root->right);
        }
        return result;
    }
    vector<int> postOrder(TreeNode* root) {
        vector<int> result;
        while (root != NULL) {
            if (root->left)     preOrder(root->left);
            if (root->right)    postOrder(root->right);
            result.push_back(root->val);
        }
        return result;
    }
    bool isSymmetric(TreeNode* root) {
        vector<int> resultPre = preOrder(root);
        vector<int> resultPost = postOrder(root);
        if (resultPre.size() != resultPost.size())  
            return false;
        for (int i = 0; i < resultPost.size(); i++) {
            if (resultPre[i] != resultPost[i])  
                return false;
        }
        return true;
    }
};

• 其实我觉得这个思路没问题 把这颗树前序后序遍历 判断遍历结果是否刚好相反 但是时间超出了限制
• 下面是看了思路后的代码 递归版本----使用队列的迭代版本------使用栈的迭代版本

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left == NULL && right != NULL)  return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        else if (left->val != right->val)   return false;
        else {
            bool outside = compare(left->left, right->right);
            bool inside = compare(left->right, right->left);
            return (outside && inside);
        }
    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL)   return true;
        return compare(root->left, root->right);
    }
};

• 递归版 要抓住递归三部曲 看了思路后比较好写 但是不看的话自己很难写出来

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*> que1;
        if (root == NULL)   return true;
        que1.push(root->left);
        que1.push(root->right);

        while (!que1.empty()) {
            TreeNode* leftNode = que1.front();
            que1.pop();
            TreeNode* rightNode = que1.front();
            que1.pop();

            if (!leftNode && !rightNode)    continue;
            if (!leftNode || !rightNode || leftNode->val != rightNode->val)    return false;

            que1.push(leftNode->left);
            que1.push(rightNode->right);
            que1.push(leftNode->right);
            que1.push(rightNode->left);
        }
        return true;
    }
};

• 使用队列的迭代法
• 思路 先判断最初的根是否为空 是空则True 不是则入队左右结点 开始进入while循环 循环里 { 从队头依次取两个元素 进行判断 若两者都为空则说明当前两结点是相等的则continue结束本轮并进入下一轮循环 若其中一个为空一个不为空 或者两者都不为空但元素值不相等 则false 这些判断过后 只剩下两者都不为空且当前元素相等的情况了 则进行接下来的操作：入队左节点的左孩子 右节点的右孩子 左节点的右孩子 右节点的左孩子 } 队列为空则循环结束 返回true

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        stack<TreeNode*> st;
        if (root == NULL)   return true;
        st.push(root->left);
        st.push(root->right);

        while (!st.empty()) {
            TreeNode* leftNode = st.top();
            st.pop();
            TreeNode* rightNode = st.top();
            st.pop();

            if (!leftNode && !rightNode)    continue;
            if (!leftNode || !rightNode || leftNode->val != rightNode->val)    return false;

            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};

• 因为迭代法用到的队列 其实是把左右两个子树要比较的元素顺序放进一个容器，然后成对成对的取出来进行比较，那么其实使用栈也是可以的 代码只要把队列原封不动的改成栈就可以了