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

一、参考资料

层序遍历 10

题目链接/文章讲解/视频讲解：https://programmercarl.com/0102.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E5%B1%82%E5%BA%8F%E9%81%8D%E5%8E%86.html

翻转二叉树 （优先掌握递归）

题目链接/文章讲解/视频讲解：https://programmercarl.com/0226.%E7%BF%BB%E8%BD%AC%E4%BA%8C%E5%8F%89%E6%A0%91.html

对称二叉树 （优先掌握递归）

题目链接/文章讲解/视频讲解：https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html

二、层序遍历 10 - 以一打十系列

LeetCode102.二叉树的层序遍历

https://leetcode.cn/problems/binary-tree-level-order-traversal/description/

给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。

示例 1：（如上图）

输入：root = [3,9,20,null,null,15,7] 输出：[[3],[9,20],[15,7]]
示例 2：
输入：root = [1] 输出：[[1]]
示例 3：
输入：root = [] 输出：[]
提示：
树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     // version 1：队列法
  15.     vector<vector<int>> levelOrder(TreeNode* root) {
  16.         queue<TreeNode*> que;
  17.         vector<vector<int>> res;
  18.         if (root != NULL) que.push(root);
  19.         while(!que.empty()) {
  20.             
  21.             vector<int> vec;
  22.             int size = que.size();
  23.             for (int i = 0; i < size; i++) {
  24.                 TreeNode* node = que.front();
  25.                 que.pop();
  26.                 vec.push_back(node->val);
  27.                 if (node->left) que.push(node->left);
  28.                 if (node->right) que.push(node->right);
  29.             }
  30.             res.push_back(vec);
  31.         }
  32.         return res;
  33.     }
  34. };
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     // version2：递归版
  15.     void order (TreeNode* cur, vector<vector<int>>& result, int depth) {
  16.         if (cur == NULL) return ;
  17.         if (result.size() == depth) result.push_back(vector<int>());
  18.         result[depth].push_back(cur->val);
  19.         order(cur->left, result, depth + 1);
  20.         order(cur->right, result, depth + 1);
  21.     }
  22.     vector<vector<int>> levelOrder(TreeNode* root) {
  23.         vector<vector<int>> result;
  24.         int depth = 0;
  25.         order(root, result, depth);
  26.         return result;
  27.     }
  28. };
  29. // 记忆中 递归法不是很理解呢

LeetCode107.二叉树的层次遍历II

https://leetcode.cn/problems/binary-tree-level-order-traversal-ii/description/

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

示例 1：（如上图）

输入：root = [3,9,20,null,null,15,7] 输出：[[15,7],[9,20],[3]]
示例 2：
输入：root = [1] 输出：[[1]]
示例 3：
输入：root = [] 输出：[]
提示：
树中节点数目在范围 [0, 2000] 内
-1000 <= Node.val <= 1000 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<vector<int>> levelOrderBottom(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<vector<int>> res;
  17.         if (root != NULL) que.push(root);
  18.         while (!que.empty()) {
  19.             int size = que.size();
  20.             vector<int> vec;
  21.             for (int i = 0; i < size; i++) {
  22.                 TreeNode* node = que.front();
  23.                 que.pop();
  24.                 vec.push_back(node->val);
  25.                 if (node->left) que.push(node->left);
  26.                 if (node->right) que.push(node->right);
  27.             }
  28.             res.push_back(vec);
  29.         }
  30.         reverse(res.begin(), res.end());
  31.         return res;
  32.     }
  33. };

LeetCode199.二叉树的右视图

https://leetcode.cn/problems/binary-tree-right-side-view/description/

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4] 输出: [1,3,4]
示例 2:
输入: [1,null,3] 输出: [1,3]
示例 3:
输入: [] 输出: []
提示:
二叉树的节点个数的范围是 [0,100]
-100 <= Node.val <= 100 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<int> rightSideView(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<int> res;
  17.         if (root != NULL) que.push(root);
  18.         while (!que.empty()) {
  19.             int size = que.size();
  20.             for (int i = 0; i < size; i++) {
  21.                 TreeNode* node = que.front();
  22.                 que.pop();
  23.                 if (i == (size - 1)) res.push_back(node->val);
  24.                 if (node->left) que.push(node->left);
  25.                 if (node->right) que.push(node->right);
  26.             }
  27.         }
  28.         return res;
  29.     }
  30. };

LeetCode637.二叉树的层平均值

https://leetcode.cn/problems/average-of-levels-in-binary-tree/description/

给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。

示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：[3.00000,14.50000,11.00000] 解释：第 0 层的平均值为 3,第 1 层的平均值为 14.5,第 2 层的平均值为 11 。 因此返回 [3, 14.5, 11] 。
示例 2:
输入：root = [3,9,20,15,7] 输出：[3.00000,14.50000,11.00000]
提示：
树中节点数量在 [1, 10^4] 范围内
-2^31 <= Node.val <= 2^31 - 1 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<double> averageOfLevels(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<double> avg;
  17.         if (root != NULL) que.push(root);
  18.         while (!que.empty()) {
  19.             int size = que.size();
  20.             long sum = 0;
  21.             for (int i = 0; i < size; i++) {
  22.                 TreeNode* node = que.front();
  23.                 que.pop();
  24.                 sum += node->val;
  25.                 if (node->left) que.push(node->left);
  26.                 if (node->right) que.push(node->right);
  27.             }
  28.             avg.push_back(sum*1.0 / size);
  29.             sum = 0;
  30.         }
  31.         return avg;
  32.     }
  33. };

LeetCode429.N叉树的层序遍历

https://leetcode.cn/problems/binary-tree-right-side-view/description/

示例一图片：

示例二图片：

给定一个 N 叉树，返回其节点值的 层序遍历。（即从左到右，逐层遍历）。
树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。

示例 1：
输入：root = [1,null,3,2,4,null,5,6] 输出：[[1],[3,2,4],[5,6]]
示例 2：
输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14] 输出：[[1],[2,3,4,5],[6,7,8,9,10],[11,12,13],[14]]
提示：
树的高度不会超过 1000
树的节点总数在 [0, 10^4] 之间 
  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     vector<Node*> children;
  8.     Node() {}
  10.     Node(int _val) {
  11.         val = _val;
  12.     }
  14.     Node(int _val, vector<Node*> _children) {
  15.         val = _val;
  16.         children = _children;
  17.     }
  18. };
  19. */
  20.  
  21. class Solution {
  22. public:
  23.     vector<vector<int>> levelOrder(Node* root) {
  24.         queue<Node*> que;
  25.         vector<vector<int>> res;
  26.         if (root != NULL) que.push(root);
  27.         while (!que.empty()) {
  28.             int size = que.size();
  29.             vector<int> vec;
  30.             for (int i = 0; i < size; i++){
  31.                 Node* node = que.front();
  32.                 que.pop();
  33.                 vec.push_back(node->val);
  34.                 // 将节点孩子加入队列
  35.                 for (int j = 0; j < node->children.size(); j++) {
  36.                     if (node->children[j]) que.push(node->children[j]);
  37.                 }
  38.             }
  39.             res.push_back(vec);
  40.         }
  41.         return res;
  42.     }
  43. };

LeetCode515.在每个树行中找最大值

https://leetcode.cn/problems/find-largest-value-in-each-tree-row/description/

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：
输入: root = [1,3,2,5,3,null,9] 输出: [1,3,9]
示例2：
输入: root = [1,2,3] 输出: [1,3]
提示：
二叉树的节点个数的范围是 [0,10^4]
-2^31 <= Node.val <= 2^31 - 1 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     vector<int> largestValues(TreeNode* root) {
  15.         queue<TreeNode*> que;
  16.         vector<int> res;
  17.         if (root != NULL) que.push(root);
  18.         while (!que.empty()) {
  19.             int size = que.size();
  20.             int maxValue = INT_MIN;
  21.             for (int i = 0; i < size; i++) {
  22.                 TreeNode* node = que.front();
  23.                 que.pop();
  24.                 maxValue = node->val > maxValue ? node->val : maxValue;
  25.                 if (node->left) que.push(node->left);
  26.                 if (node->right) que.push(node->right);
  27.             }
  28.             res.push_back(maxValue);
  29.         }
  30.         return res;
  31.     }
  32. };

LeetCode116.填充每个节点的下一个右侧节点指针

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node/description/

给定一个 完美二叉树 ，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
struct Node { int val; Node *left; Node *right; Node *next; }
填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。
初始状态下，所有 next 指针都被设置为 NULL。

示例 1：（如上图）
输入：root = [1,2,3,4,5,6,7] 输出：[1,#,2,3,#,4,5,6,7,#] 解释：给定二叉树如图 A 所示，你的函数应该填充它的每个 next 指针，以指向其下一个右侧节点，如图 B 所示。序列化的输出按层序遍历排列，同一层节点由 next 指针连接，'#' 标志着每一层的结束。
示例 2:
输入：root = [] 输出：[]
提示：
树中节点的数量在 [0, 2^12 - 1] 范围内
-1000 <= node.val <= 1000
进阶：
你只能使用常量级额外空间。
使用递归解题也符合要求，本题中递归程序占用的栈空间不算做额外的空间复杂度。 
  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     Node* left;
  7.     Node* right;
  8.     Node* next;
  10.     Node() : val(0), left(NULL), right(NULL), next(NULL) {}
  12.     Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
  14.     Node(int _val, Node* _left, Node* _right, Node* _next)
  15.         : val(_val), left(_left), right(_right), next(_next) {}
  16. };
  17. */
  18.  
  19. class Solution {
  20. public:
  21.     Node* connect(Node* root) {
  22.         queue<Node*> que;
  23.         if (root != NULL) que.push(root);
  24.         while (!que.empty()){
  25.             int size = que.size();
  26.             Node* nodePre;
  27.             Node* node;
  28.             for (int i = 0; i < size; i++) {
  29.                 if (i == 0) {
  30.                     nodePre = que.front();
  31.                     que.pop();
  32.                     node = nodePre;
  33.                 } else {
  34.                     node = que.front();
  35.                     que.pop();
  36.                     nodePre->next = node;
  37.                     nodePre = nodePre->next;
  38.                 }
  39.                 if (node->left) que.push(node->left);
  40.                 if (node->right) que.push(node->right);
  41.             }
  42.             nodePre->next = NULL;
  43.         }
  44.         return root;
  45.     }
  46. };

LeetCode117.填充每个节点的下一个右侧节点指针II——代码和上个题一模一样

https://leetcode.cn/problems/populating-next-right-pointers-in-each-node-ii/description/

  1. /*
  2. // Definition for a Node.
  3. class Node {
  4. public:
  5.     int val;
  6.     Node* left;
  7.     Node* right;
  8.     Node* next;
  10.     Node() : val(0), left(NULL), right(NULL), next(NULL) {}
  12.     Node(int _val) : val(_val), left(NULL), right(NULL), next(NULL) {}
  14.     Node(int _val, Node* _left, Node* _right, Node* _next)
  15.         : val(_val), left(_left), right(_right), next(_next) {}
  16. };
  17. */
  18.  
  19. class Solution {
  20. public:
  21.     Node* connect(Node* root) {
  22.         queue<Node*> que;
  23.         if (root != NULL) que.push(root);
  24.         while (!que.empty()) {
  25.             int size = que.size();
  26.             Node* nodePre;
  27.             Node* node;
  28.             for (int i = 0; i <size; i++) {
  29.                 if (i == 0) {
  30.                     nodePre = que.front();
  31.                     que.pop();
  32.                     node = nodePre;
  33.                 } else {
  34.                     node = que.front();
  35.                     que.pop();
  36.                     nodePre->next = node;
  37.                     nodePre = nodePre->next;
  38.                 }
  39.                 if (node->left) que.push(node->left);
  40.                 if (node->right) que.push(node->right);
  41.             }
  42.             nodePre->next = NULL;
  43.         }
  44.         return root;
  45.     }
  46. };

LeetCode104.二叉树的最大深度

https://leetcode.cn/problems/maximum-depth-of-binary-tree/description/

给定一个二叉树，找出其最大深度。
二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
说明: 叶子节点是指没有子节点的节点。
示例：
给定二叉树 [3,9,20,null,null,15,7]，
3 / \ 9 20 / \ 15 7
返回它的最大深度 3 。 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     int maxDepth(TreeNode* root) {
  15.         int depth = 0;
  16.         if (root == NULL) return 0;
  17.         queue<TreeNode*> que;
  18.         que.push(root);
  19.         while (!que.empty()) {
  20.             int size = que.size();
  21.             depth++;
  22.             for (int i = 0; i < size; i++) {
  23.                 TreeNode* node = que.front();
  24.                 que.pop();
  25.                 if (node->left) que.push(node->left);
  26.                 if (node->right) que.push(node->right);
  27.             }
  28.         }
  29.         return depth;
  30.     }
  31. };

LeetCode111.二叉树的最小深度

https://leetcode.cn/problems/minimum-depth-of-binary-tree/description/

给定一个二叉树，找出其最小深度。
最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
说明：叶子节点是指没有子节点的节点。

示例 1：
输入：root = [3,9,20,null,null,15,7] 输出：2
示例 2：
输入：root = [2,null,3,null,4,null,5,null,6] 输出：5
提示：
树中节点数的范围在 [0, 105] 内
-1000 <= Node.val <= 1000 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     int minDepth(TreeNode* root) {
  15.         if (root == NULL) return 0;
  16.         int depth = 0;
  17.         queue<TreeNode*> que;
  18.         que.push(root);
  19.         while (!que.empty()) {
  20.             int size = que.size();
  21.             depth++;
  22.             for (int i = 0; i < size; i++) {
  23.                 TreeNode* node = que.front();
  24.                 que.pop();
  25.                 if (node->left) que.push(node->left);
  26.                 if (node->right) que.push(node->right);
  27.                 if (!node->left && !node->right) {
  28.                     return depth;
  29.                 }
  30.             }
  31.         }
  32.         return depth;
  33.  
  34.     }
  35. };

三、翻转二叉树 （优先掌握递归）

https://leetcode.cn/problems/invert-binary-tree/description/

给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
示例 1：（如上图）
输入：root = [4,2,7,1,3,6,9] 输出：[4,7,2,9,6,3,1]
示例 2：
输入：root = [2,1,3] 输出：[2,3,1]
示例 3：
输入：root = [] 输出：[]

提示：
树中节点数目范围在 [0, 100] 内
-100 <= Node.val <= 100 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     // version 1: 广度优先遍历
  15.     TreeNode* invertTree(TreeNode* root) {
  16.         queue<TreeNode*> que;
  17.         if (root != NULL) que.push(root);
  18.         while (!que.empty()) {
  19.             int size = que.size();
  20.             for (int i = 0; i < size; i++) {
  21.                 TreeNode* node = que.front();
  22.                 que.pop();
  23.                 swap (node->left, node->right);
  24.                 if (node->left) que.push(node->left);
  25.                 if (node->right) que.push(node->right);
  26.             }
  27.         }
  28.         return root;
  29.     }
  30. };
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     // version2: 递归法
  15.     TreeNode* invertTree(TreeNode* root) {
  16.         if (root == NULL) return root;
  17.         swap(root->left, root->right);  // 中
  18.         invertTree(root->left);         // 左
  19.         invertTree(root->right);        // 右
  20.         return root;
  21.     }
  22. };
  23.  
  24. 或
  25. class Solution {
  26. public:
  27.     // version2: 递归法
  28.     TreeNode* invertTree(TreeNode* root) {
  29.         if (root == NULL) return root;
  30.         
  31.         invertTree(root->left);         // 左
  32.         invertTree(root->right);        // 右
  33.         swap(root->left, root->right);  // 中
  34.         return root;
  35.     }
  36. };
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     // version3: 迭代法 —— 使用栈
  15.     TreeNode* invertTree(TreeNode* root) {
  16.         if (root == NULL) return root;
  17.         stack<TreeNode*> st;
  18.         st.push(root);
  19.         while (!st.empty()) {
  20.             TreeNode* node = st.top();   // 中
  21.             st.pop();
  22.             swap(node->left, node->right);
  23.             if (node->left) st.push(node->left);
  24.             if (node->right) st.push(node->right);
  25.         }
  26.         return root;
  27.     }
  28. };
  29.  
  30. 或
  31.  
  32. class Solution {
  33. public:
  34.     // version3: 迭代法 —— 使用栈
  35.     TreeNode* invertTree(TreeNode* root) {
  36.         if (root == NULL) return root;
  37.         stack<TreeNode*> st;
  38.         st.push(root);
  39.         while (!st.empty()) {
  40.             TreeNode* node = st.top();   // 中
  41.             st.pop();
  42.             swap(node->left, node->right);
  43.             
  44.             if (node->right) st.push(node->right);
  45.             if (node->left) st.push(node->left);
  46.         }
  47.         return root;
  48.     }
  49. };
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14. //version4：统一迭代法，这种写法记不住
  15.     TreeNode* invertTree(TreeNode* root) {
  16.         stack<TreeNode*> st;
  17.         if (root != NULL) st.push(root);
  18.         while (!st.empty()) {
  19.             TreeNode* node = st.top();
  20.             if (node != NULL) {
  21.                 st.pop();
  22.                 if (node->right) st.push(node->right);  // 右
  23.                 if (node->left) st.push(node->left);    // 左
  24.                 st.push(node);                          // 中
  25.                 st.push(NULL);
  26.             } else {
  27.                 st.pop();
  28.                 node = st.top();
  29.                 st.pop();
  30.                 swap(node->left, node->right);          // 节点处理逻辑
  31.             }
  32.         }
  33.         return root;
  34.     }
  35. };

四、对称二叉树 （优先掌握递归）

https://leetcode.cn/problems/symmetric-tree/description/

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

示例 1：（如上图）
输入：root = [1,2,2,3,4,4,3] 输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3] 输出：false
提示：
树中节点数目在范围 [1, 1000] 内
-100 <= Node.val <= 100

进阶：你可以运用递归和迭代两种方法解决这个问题吗？ 
  1. /**
  2.  * Definition for a binary tree node.
  3.  * struct TreeNode {
  4.  *     int val;
  5.  *     TreeNode *left;
  6.  *     TreeNode *right;
  7.  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
  8.  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
  9.  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
  10.  * };
  11.  */
  12. class Solution {
  13. public:
  14.     bool compare(TreeNode* left, TreeNode* right) {
  15.         // 首先排除空节点的情况
  16.         if (left == NULL && right != NULL) return false;
  17.         else if (left != NULL && right == NULL) return false;
  18.         else if (left == NULL && right == NULL) return true;
  19.         // 排除了空节点，再排除数值不相同的情况
  20.         else if (left->val != right->val) return false;
  21.  
  22.         // 此时就是：左右节点都不为空，且数值相同的情况
  23.         // 此时才做递归，做下一层的判断
  24.         bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
  25.         bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
  26.         bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
  27.         return isSame;
  28.  
  29.     }
  30.     bool isSymmetric(TreeNode* root) {
  31.         if (root == NULL) return true;
  32.         return compare(root->left, root->right);
  33.     }
  34. };

迭代法：（还没掌握）

https://programmercarl.com/0101.%E5%AF%B9%E7%A7%B0%E4%BA%8C%E5%8F%89%E6%A0%91.html#%E8%BF%AD%E4%BB%A3%E6%B3%95

当日不写总结就忘记刷题时的真实感受了呜呜呜，继续补博客

刷题加油鸭~~

posted @ 2023-01-31 16:35  ZYM-爱吃柚子的程序媛  阅读(781)  评论(0)    收藏  举报