LeetCode_101 对称二叉树

1、题目：对称二叉树

给你一个二叉树的根节点 root ， 检查它是否轴对称。

2、解题思路

方法一：递归

1、确定递归函数的参数和返回值

因为我们要比较的是根节点的两个子树是否是相互翻转的，进而判断这个树是不是对称树，所以要比较的是两个树，参数自然也是左子树节点和右子树节点。

返回值自然是bool类型。

2、确定终止条件

• 左节点为空，右节点不为空，不对称，return false
• 左不为空，右为空，不对称 return false
• 左右都为空，对称，返回true
• 左右都不为空，比较节点数值，不相同就return false

3、确定单层递归的逻辑

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
• 比较内测是否对称，传入左节点的右孩子，右节点的左孩子。
• 如果左右都对称就返回true ，有一侧不对称就返回false 。

方法二：迭代

可以通过队列或者栈将一对一对的数据存入并读取出来去判断是否相等。但实际上用栈和队列效果是一模一样的，因为我们存入和取出的时候都是一对一对的。

3、代码

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;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

    }
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) 
            return true;
        return compare(root->left, root->right);
    }
};

//队列
class Solution 
{
public:
    bool isSymmetric(TreeNode* root) 
    {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) 
        {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); 
            que.pop();
            TreeNode* rightNode = que.front(); 
            que.pop();
            if (!leftNode && !rightNode) 
            {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) 
            {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};

//栈
class Solution 
{
public:
    bool isSymmetric(TreeNode* root) 
    {
        if (root == NULL) return true;
        stack<TreeNode*> st; // 这里改成了栈
        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;
    }
};