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

xux1aot1an

已于 2023-03-29 23:28:36 修改

阅读量73

点赞数

文章标签：算法 leetcode

于 2023-03-29 21:56:59 首次发布

本文链接：https://blog.csdn.net/xux1aot1an/article/details/129843259

版权

文章详细介绍了如何使用迭代和递归方法解决LeetCode中的102题（二叉树的层序遍历）和226题（翻转二叉树）。对于层序遍历，通过队列实现，用NULL分隔不同层级；递归法中，通过额外的深度参数来区分层次。翻转二叉树则可以通过递归或迭代（前序、层序遍历变种）实现，关键在于交换节点的左右子树。

摘要由CSDN通过智能技术生成

LeetCode 102 二叉树的层序遍历

题目链接：102

迭代法

思路：迭代法的层序遍历，与广度优先搜索相同，通过队列存放待处理元素。为了进行分层存放，采用一个NULL指针隔开每层，当弹出一个NULL时，说明遍历完当前层，此时队列中为全部的下层元素，因此再插入一个NULL。
代码：

/**
 * 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) {
            que.push(root);
            que.push(NULL);
        }
        vector<int> layer;
        while (!que.empty()) {
            TreeNode* cur = que.front();
            que.pop();

            if (cur) {
                layer.push_back(cur->val);
                if (cur->left) que.push(cur->left);
                if (cur->right) que.push(cur->right);
            } else {
                result.push_back(layer);
                layer.clear();
                if (!que.empty()) que.push(NULL);
            }
        }
        return result;

    }
};

递归法

思路：为了分层存放，递归函数的参数中除了当前节点和结果数组外，还应有一个深度，无返回值。递归的终止条件为当前节点为NULL。在单层递归中，先将当前节点放入对应深度的数组中，再处理左右子树。实际上，各节点的处理顺序并非层序，但最终的结果与层序遍历的结果相同。

/**
 * 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:
    void order(TreeNode* root, vector<vector<int>>& nodes, int depth) {
        if (root == NULL) return;
        if (nodes.size() < depth) nodes.push_back(vector<int>());
        nodes[depth-1].push_back(root->val);
        order(root->left, nodes, depth+1);
        order(root->right, nodes, depth+1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result;
        order(root, result, 1);
        return result;
    }
};

LeetCode 226 翻转二叉树

题目链接：262

递归

思路：可参考前序遍历，此时对一个节点的处理操作为交换该节点的左右孩子（并非交换左右孩子的值，而是交换两棵子树）。
代码：

/**
 * 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;
    }
};

迭代-前序

思路：参考前序遍历的迭代
代码：

/**
 * 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*> stk;

        if (root) stk.push(root);
        while (!stk.empty()) {
            TreeNode* cur = stk.top();
            stk.pop();
            swap(cur->left, cur->right);
            if (cur->left) stk.push(cur->left);
            if (cur->right) stk.push(cur->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) {
        queue<TreeNode*> que;

        if (root) que.push(root);
        while (!que.empty()) {
            TreeNode* cur = que.front();
            que.pop();
            swap(cur->left, cur->right);
            if (cur->left) que.push(cur->left);
            if (cur->right) que.push(cur->right);
        }

        return root;
    }
};

LeetCode 101 对称二叉树

题目链接：101

递归

思路：对称二叉树即比较根节点的两棵子树是否对称，因此递归函数的参数为待比较的两棵树的根节点，返回值为bool；递归结束条件为至少一个节点为NULL；在单层递归中，先比较两个节点是否相等，再比较左节点的左子树和右节点的右子树是否相等，再比较左节点的右子树和右节点的左子树是否相等；若两次比较都相等，则返回true
代码：

/**
 * 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 false;
        if (left!=NULL && right==NULL) return false;
        if (left==NULL && right==NULL) return true;

        if (left->val != right->val) return false;
        bool check_outside = compare(left->left, right->right);
        bool check_inside = compare(left->right, right->left);
        return check_inside && check_outside;
    }

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

迭代

思路：迭代解法，即同时遍历左右子树，并比较对称位置节点是否相等。每次从队列弹出两个节点进行比较，并将两个节点的孩子压入队列，其中，两个对称位置的孩子需依次压入，以便之后能同时弹出进行比较。
代码：

/**
 * 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) return true;
        que.push(root->left);
        que.push(root->right);
        while (!que.empty()) {
            TreeNode* node1 = que.front();
            que.pop();
            TreeNode* node2 = que.front();
            que.pop();

            if (node1 != NULL && node2 == NULL) return false;
            else if (node1 == NULL && node2 != NULL) return false;
            else if (node1 == NULL && node2 == NULL) continue;
            else if (node1->val != node2->val) return false;

            que.push(node1->left);
            que.push(node2->right);
            que.push(node1->right);
            que.push(node2->left);
        }

        return true;
    }
};