前序遍历
144. 二叉树的前序遍历
前序遍历:根结点 —> 左子树 —> 右子树
递归法
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
vec.push_back(cur->val); // 中
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};
迭代法
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
if (root == nullptr){
return {};
}
vector<int> res;
stack<TreeNode*> stk;
stk.push(root);
while (!stk.empty()) {
TreeNode* cur = stk.top(); // 访问栈顶结点
stk.pop();
res.push_back(cur->val);
if(cur->right != nullptr) { // 将右子节点(如果有)压入栈
stk.push(cur->right);
}
if(cur->left != nullptr) { // 将左子节点(如果有)压入栈
stk.push(cur->left);
}
}
return res;
}
};
中序遍历
94. 二叉树的中序遍历
中序遍历:左子树—> 根结点 —> 右子树
递归法
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
traversal(cur->left, vec); // 左
vec.push_back(cur->val); // 中
traversal(cur->right, vec); // 右
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};
迭代法
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> stk;
while(!stk.empty() || root != nullptr){
while (root != nullptr) {
// 将父节点,父节点的左子节点,左子节点的左子节点,... ,直到访问到最底层,依次入栈
stk.push(root);
root = root->left; // 先遍历左子树
}
root = stk.top();
stk.pop();
res.push_back(root->val); // 访问当前节点
root = root->right; // 访问右子树
}
return res;
}
};
后序遍历
145. 二叉树的后序遍历
后序遍历:左子树 —> 右子树 —> 根结点
递归法
class Solution {
public:
void traversal(TreeNode* cur, vector<int>& vec) {
if (cur == NULL) return;
traversal(cur->left, vec); // 左
traversal(cur->right, vec); // 右
vec.push_back(cur->val); // 中
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> result;
traversal(root, result);
return result;
}
};
迭代法
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
stack<TreeNode*> stk;
TreeNode *prev = nullptr;
while(!stk.empty() || root != nullptr){
while (root != nullptr) {
stk.push(root);
root = root->left;
}
root = stk.top();
stk.pop();
if (root->right == nullptr || root->right == prev) {
res.push_back(root->val);
prev = root;
root = nullptr;
}
else {
stk.push(root);
root = root->right;
}
}
return res;
}
};
层序遍历
层次遍历:只需按层次遍历即可
102.二叉树的层序遍历
广度优先遍历
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> res;
if (root == nullptr) {
return {};
}
queue<TreeNode*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
vector<int> temp;
while (size) {
TreeNode* cur = que.front();
que.pop();
temp.push_back(cur->val);
if (cur->left) {
que.push(cur->left);
}
if (cur->right) {
que.push(cur->right);
}
--size;
}
res.push_back(temp);
}
return res;
}
};
递归法
class Solution {
public:
void order(TreeNode* cur, vector<vector<int>>& result, int depth)
{
if (cur == nullptr) return;
if (result.size() == depth) result.push_back(vector<int>());
result[depth].push_back(cur->val);
order(cur->left, result, depth + 1);
order(cur->right, result, depth + 1);
}
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> result;
int depth = 0;
order(root, result, depth);
return result;
}
};
107.二叉树的层次遍历II
将102的结果反转reverse(res.begin(), res.end());
;
class Solution {
public:
vector<vector<int>> levelOrderBottom(TreeNode* root) {
vector<vector<int>> res;
if (root == nullptr) {
return {};
}
queue<TreeNode*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
vector<int> temp;
while (size) {
TreeNode* cur = que.front();
que.pop();
temp.push_back(cur->val);
if(cur->left) {
que.push(cur->left);
}
if(cur->right) {
que.push(cur->right);
}
--size;
}
res.push_back(temp);
}
reverse(res.begin(), res.end());
return res;
}
};
199.二叉树的右视图
199.二叉树的右视图
找到层序遍历的每一层的最后一个节点
class Solution {
public:
vector<int> rightSideView(TreeNode* root) {
vector<int> res;
if(root == nullptr) {
return {};
}
queue<TreeNode*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
TreeNode* cur = nullptr;
while (size) {
cur = que.front();
que.pop();
if(cur->left) {
que.push(cur->left);
}
if(cur->right) {
que.push(cur->right);
}
--size;
}
res.push_back(cur->val);
}
return res;
}
};
637.二叉树的层平均值
class Solution {
public:
vector<double> averageOfLevels(TreeNode* root) {
vector<double> res;
if(root == nullptr) {
return {};
}
queue<TreeNode*> que;
que.push(root);
while(!que.empty()) {
int size = que.size();
double sum = 0.0;
double n = size;
while (size) {
TreeNode* cur = que.front();
que.pop();
sum += cur->val; //计算每一层的元素和
if(cur->left) {
que.push(cur->left);
}
if(cur->right) {
que.push(cur->right);
}
--size;
}
res.push_back(sum / n);
}
return res;
}
};
429.N叉树的层序遍历
429.N叉树的层序遍历
102变形,这里只需要将判断左右子节点,改为判断存储子节点的children数组即可
/*
// Definition for a Node.
class Node {
public:
int val;
vector<Node*> children;
Node() {}
Node(int _val) {
val = _val;
}
Node(int _val, vector<Node*> _children) {
val = _val;
children = _children;
}
};
*/
class Solution {
public:
vector<vector<int>> levelOrder(Node* root) {
if (root == nullptr) {
return {};
}
vector<vector<int>> res;
queue<Node*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
vector<int> temp;
while (size) {
Node* cur = que.front();
que.pop();
temp.push_back(cur->val);
for(int i = 0; i < cur->children.size(); ++i) {
// 遍历子节点数组,将子节点push进队列
que.push(cur->children[i]);
}
--size;
}
res.push_back(temp);
}
return res;
}
};
515.在每个树行中找最大值
class Solution{
public:
vector<int> largestValues(TreeNode* root) {
vector<int> res;
if(root == nullptr) {
return {};
}
queue<TreeNode*> que;
que.push(root);
while(!que.empty()) {
int size = que.size();
int maxVal = INT_MIN;
while (size) {
TreeNode* cur = que.front();
que.pop();
maxVal = max(maxVal, cur->val); //更新最大值
if(cur->left) {
que.push(cur->left);
}
if(cur->right) {
que.push(cur->right);
}
--size;
}
res.push_back(maxVal);
}
return res;
}
};
116.填充每个节点的下一个右侧节点指针
class Solution {
public:
Node* connect(Node* root) {
if (root == nullptr) {
return nullptr;
}
queue<Node*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
Node* cur = nullptr;
while (size) {
cur = que.front();
que.pop();
--size;
if (size > 0) { //链接当前节点所在层的下一个元素(如果存在)
cur->next = que.front();
}
if (cur->left) {
que.push(cur->left);
}
if (cur->right) {
que.push(cur->right);
}
}
}
return root;
}
};
117.填充每个节点的下一个右侧节点指针II
117.填充每个节点的下一个右侧节点指针II
和116一样的方法,层序遍历,链接当前层的节点
class Solution {
public:
Node* connect(Node* root) {
if (root == nullptr) {
return nullptr;
}
queue<Node*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
Node* cur = nullptr;
while (size) {
cur = que.front();
que.pop();
--size;
if (size > 0) { //链接当前节点所在层的下一个元素(如果存在)
cur->next = que.front();
}
if (cur->left) {
que.push(cur->left);
}
if (cur->right) {
que.push(cur->right);
}
}
}
return root;
}
};
104.二叉树的最大深度
递归法
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root == nullptr) {
return 0;
}
return max(maxDepth(root->left),maxDepth(root->right)) + 1;
}
};
广度优先遍历
计算二叉树的最大深度即计算二叉树的层数;
class Solution {
public:
int maxDepth(TreeNode* root) {
int depth = 0;
if (root == nullptr) {
return 0;
}
queue<TreeNode*> que;
que.push(root);
while (!que.empty()) {
int size = que.size();
while (size) {
TreeNode* cur = que.front();
que.pop();
if (cur->left) {
que.push(cur->left);
}
if (cur->right) {
que.push(cur->right);
}
--size;
}
++depth;
}
return depth;
}
};
111.二叉树的最小深度
递归法
class Solution {
public:
int minDepth(TreeNode* root) {
if(root == nullptr) {
return 0;
}
if(root->left == nullptr) {
return minDepth(root->right) + 1;
}
if(root->right == nullptr) {
return minDepth(root->left) + 1;
}
return min(minDepth(root->left),minDepth(root->right)) + 1;
}
};
广度优先遍历
叶子节点所在的层数即为它的深度,层序遍历可以保证最先访问到的叶子节点深度最小,即整棵二叉树的最小深度。
class Solution {
public:
int minDepth(TreeNode* root) {
if(root == nullptr) {
return 0;
}
queue<TreeNode*> que;
int res = 1; //根节点不为空,深度初始值设为 1
que.push(root);
while(!que.empty()) {
TreeNode* cur = nullptr;
int size = que.size();
while (size) {
cur = que.front();
que.pop();
if(cur->left == nullptr && cur->right == nullptr) {
return res; //是叶子节点,返回它的深度
}
if(cur->left) {
que.push(cur->left);
}
if(cur->right) {
que.push(cur->right);
}
--size;
}
++res;
}
return res;
}
};