LeetCode Hot 100：二叉树

94. 二叉树的中序遍历

思路 1：递归

/*** 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 {
private:vector<int> ans;public:vector<int> inorderTraversal(TreeNode* root) {helper(root);return ans;}void helper(TreeNode* root) {if (root == nullptr)return;helper(root->left);ans.push_back(root->val);helper(root->right);}
};

104. 二叉树的最大深度

思路 1：递归

/*** 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:int maxDepth(TreeNode* root) {return root ? max(maxDepth(root->left), maxDepth(root->right)) + 1 : 0;}
};

思路 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:int maxDepth(TreeNode* root) {if (root == nullptr)return 0;queue<TreeNode*> q;q.push(root);int depth = 0;while (!q.empty()) {int sz = q.size();for (int i = 0; i < sz; i++) {TreeNode* node = q.front();q.pop();if (node->left)q.push(node->left);if (node->right)q.push(node->right);}depth++;}return depth;}
};

226. 翻转二叉树

思路 1：自底向上递归

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

思路 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:TreeNode* invertTree(TreeNode* root) {if (root == nullptr)return root;TreeNode* l = invertTree(root->left);TreeNode* r = invertTree(root->right);root->left = r;root->right = l;return root;}
};

101. 对称二叉树

思路 1：递归

/*** 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) {return isSymmetric(root->left, root->right);}bool isSymmetric(TreeNode* left, TreeNode* right) {if (left == nullptr && right == nullptr)return true;if ((left && right == nullptr) || (left == nullptr && right))return false;if (left->val != right->val)return false;return isSymmetric(left->left, right->right) &&isSymmetric(left->right, right->left);}
};

思路 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) { return isSymmetric(root, root); }bool isSymmetric(TreeNode* u, TreeNode* v) {queue<TreeNode*> q;q.push(u);q.push(v);while (!q.empty()) {u = q.front();q.pop();v = q.front();q.pop();if (u == nullptr && v == nullptr)continue;if ((u && v == nullptr) || (u == nullptr && v))return false;if (u->val != v->val)return false;q.push(u->left);q.push(v->right);q.push(u->right);q.push(v->left);}return true;}
};

543. 二叉树的直径

思路 1：递归

/*** 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:int diameterOfBinaryTree(TreeNode* root) {int ans = 0;function<int(TreeNode*)> dfs = [&](TreeNode* root) {if (root == nullptr)return 0;int left = dfs(root->left);int right = dfs(root->right);ans = max(ans, left + right + 1);return max(left, right) + 1;};dfs(root);return ans - 1;}
};

102. 二叉树的层序遍历

/*** 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) {if (root == nullptr)return {};queue<TreeNode*> q;q.push(root);vector<vector<int>> ans;while (!q.empty()) {int sz = q.size();vector<int> v;for (int i = 0; i < sz; i++) {TreeNode* node = q.front();q.pop();v.push_back(node->val);if (node->left)q.push(node->left);if (node->right)q.push(node->right);}ans.push_back(v);}return ans;}
};

108. 将有序数组转换为二叉搜索树

思路 1：递归

/*** 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* sortedArrayToBST(vector<int>& nums) {return buildBST(nums, 0, nums.size() - 1);}TreeNode* buildBST(vector<int>& nums, int start, int end) {if (start > end)return nullptr;int mid = start + (end - start) / 2;TreeNode* root = new TreeNode(nums[mid]);root->left = buildBST(nums, start, mid - 1);root->right = buildBST(nums, mid + 1, end);return root;}
};

98. 验证二叉搜索树

思路 1：递归

/*** 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 isValidBST(TreeNode* root) {return isValidBST(root, LONG_LONG_MIN, LONG_LONG_MAX);}bool isValidBST(TreeNode* root, long long lower, long long upper) {if (root == nullptr)return true;if (root->val <= lower)return false;if (root->val >= upper)return false;return isValidBST(root->left, lower, root->val) &&isValidBST(root->right, root->val, upper);}
};

思路 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 {
private:vector<int> arr;public:bool isValidBST(TreeNode* root) {inOrder(root);for (int i = 0; i < arr.size() - 1; i++)if (arr[i] >= arr[i + 1])return false;return true;}void inOrder(TreeNode* root) {if (root == nullptr)return;if (root->left)inOrder(root->left);arr.push_back(root->val);if (root->right)inOrder(root->right);}
};