代码随想录算法训练营第15天 | 226.翻转二叉树， 101.对称二叉树

Leetcode - 226翻转二叉树

这道题比较简单我第一遍是那层次遍历的迭代法做的也就是bfs做的：

/**
 * 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) {
        queue<TreeNode*> que;
        if(root != NULL){
            que.push(root);
        }
        while(!que.empty()){
            int size = que.size();
            for(int i = 0; i < size; i++){
                TreeNode* node = que.front();
                que.pop();
                if(node != NULL){
                    TreeNode* x = node -> left;
                    node -> left = node -> right;
                    node -> right = x;
                    if(node -> left)    que.push(node -> left);
                    if(node -> right)   que.push(node -> right);
                }
            }
        }
        return root;
    }
};

递归法：

/**
 * 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) {
        if(root == NULL)    return root;
        swap(root -> left, root -> right);
        invertTree(root -> left);
        invertTree(root -> right);
        return root;
    }
};

dfs:

感觉跟bfs基本一样：

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

Leetcode-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:
    bool compare(TreeNode* left, TreeNode* right){
        if(left == NULL && right == NULL)   return true;
        else if(left == NULL && right != NULL)  return false;
        else if(left != NULL && right == NULL)  return false;
        else if(left -> val != right -> val)    return false;
        bool outside = compare(right -> right, left -> left);
        bool inside = compare(right -> left, left -> right);
        bool res = outside && inside;
        return res;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL)    return true;
        return compare(root -> left, root -> right);
    }
};

下面使用队列来实现的跟上面的基本一样

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) {
            return true;
        }

        std::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 == nullptr && rightNode == nullptr) {
                continue;
            }

            if (leftNode == nullptr || rightNode == nullptr || leftNode->val != rightNode->val) {
                return false;
            }

            que.push(leftNode->left);
            que.push(rightNode->right);
            que.push(leftNode->right);
            que.push(rightNode->left);
        }

        return true;
    }
};

学了一下午加一晚上二叉树了，人都要分叉了.............

2024/3/10          20:36

-------------------------------magixx