代码随想录算法训练营第十三天|层序遍历 、226.翻转二叉树、101.对称二叉树

二叉树第二天

---

一、层序遍历

队列，一层接着一层输出

/**
 * 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<vector<int>> levelOrder(TreeNode* root) {
        //层序遍历，队列实现
        queue<TreeNode*>que;
        vector<vector<int>>result;
        if (root != nullptr) que.push(root);
        while (!que.empty()) {
            int len = que.size();
            vector<int>res;
            for (int i = 0; i < len; i++) {
                TreeNode* node = que.front();
                que.pop();
                res.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vector<int>(res.begin(),res.end()));   
        }
        return result;
    }
};

二、翻转二叉树

1.开始想用层序遍历，限制条件有点多，改用迭代遍历
2.前序遍历，读取一个节点，swap该节点的左右节点

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        //反转
       stack<TreeNode*>st;
       if (root == nullptr) return root;
       st.push(root);
       while (!st.empty()) {
           TreeNode* node = st.top();
           st.pop();
           swap(node->left, node->right);
           if (node->right) st.push(node->right);
           if (node->left) st.push(node->left);
       }
       return root;
    }
};

三、对称二叉树

1.层序遍历可以做，有点麻烦
2.要比较的不是一个节点的左右孩子，而是相邻节点的左右孩子，所以单个指针不行，需要两个指针分别指向相邻节点的左右孩子，进行比较

/**
 * 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:
    bool isSymmetric(TreeNode* root) {
        queue<TreeNode*>que;
        if (root == nullptr) return true;
        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;;
            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;
    }
};

---

总结

对称二叉树有点懵，递归不太熟练，还是比较喜欢使用迭代遍历和层序遍历
学习时间110min。
学习资料：《代码随想录》。