二叉树的遍历，11/5上课有感
文章目录
- 1.树的深度
-
- 1）树的最大深度
- 2）树的最小深度
- 2.树的遍历
-
- 1）先序遍历
-
- <1>递归
- <2>迭代
- 2）中序遍历
-
- <1>递归
- <2>迭代
- 3）后序遍历
-
- <1>递归
- <2>迭代
- 4）层次遍历（BFS）
1.树的深度
1）树的最大深度
递归
LC104
class Solution {
public:
int maxDepth(TreeNode* root) {
if(root==nullptr) return 0;
return max(maxDepth(root->left),maxDepth(root->right))+1;
}
};
2）树的最小深度
用的其实就是bfs,遇到叶子节点就结束。
LC111
class Solution {
public:
int minDepth(TreeNode* root) {
if(!root) return 0;
queue<TreeNode*>que;
que.push(root);
int min_depth=0;
while(!que.empty())
{
min_depth++;
int size=que.size();
for(int i=0;i<size;i++)
{
TreeNode*temp=que.front();
que.pop();
if(!temp->left && !temp->right) return min_depth;
if(temp->left) que.push(temp->left);
if(temp->right) que.push(temp->right);
}
}
return min_depth;
}
};
2.树的遍历
1）先序遍历
<1>递归
class Solution {
void traversal(TreeNode* cur,vector<int>&vec)
{
if(cur==nullptr) return;
vec.push_back(cur->val);
traversal(cur->left,vec);
traversal(cur->right,vec);
}
public:
vector<int> preorderTraversal(TreeNode* root) {
vector<int>vec;
traversal(root,vec);
return vec;
}
};
<2>迭代
class Solution {
public:
vector<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int>result;
if(root==nullptr) return result;
st.push(root);
while(!st.empty())
{
TreeNode* node=st.top();
st.pop();
result.push_back(node->val);
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
}
return result;
}
};
2）中序遍历
<1>递归
class Solution {
void traversal(TreeNode*cur,vector<int>&vec)
{
if(cur==nullptr) return;
traversal(cur->left,vec);
vec.push_back(cur->val);
traversal(cur->right,vec);
}
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int>vec;
traversal(root,vec);
return vec;
}
};
<2>迭代
每棵子树，整棵树左边界入栈，依次弹出的过程中，打印，对弹出节点的右树继续操作。
class Solution {
public:
vector<int> inorderTraversal(TreeNode* root) {
vector<int>result;
stack<TreeNode*>st;
TreeNode*cur=root;
while(cur!=nullptr || !st.empty()){
if(cur!=nullptr)
{
st.push(cur);
cur=cur->left;
}
else{
cur=st.top();
st.pop();
result.push_back(cur->val);
cur=cur->right;
}
}
return result;
}
};
3）后序遍历
<1>递归
class Solution {
void traversal(TreeNode* root,vector<int>&result)
{
if(root==nullptr) return;
traversal(root->left,result);
traversal(root->right,result);
result.push_back(root->val);
}
public:
vector<int> postorderTraversal(TreeNode* root) {
vector<int>result;
traversal(root,result);
return result;
}
};
<2>迭代
和前序类似，也是栈。只不过最后reverse了一下。
class Solution {
public:
vector<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> st;
vector<int>result;
if(root==nullptr) return result;
st.push(root);
while(!st.empty())
{
TreeNode* node=st.top();
st.pop();
result.push_back(node->val);
if(node->left) st.push(node->left);
if(node->right) st.push(node->right);
}
reverse(result.begin(),result.end());
return result;
}
};
4）层次遍历（BFS）
class Solution {
public:
vector<vector<int>> levelOrder(TreeNode* root) {
queue<TreeNode*>que;
if(root!=nullptr) que.push(root);
vector<vector<int>>result;
while(!que.empty()){
int size=que.size();
vector<int>vec;
for(int i=0;i<size;i++)
{
TreeNode* node=que.front();
que.pop();
vec.push_back(node->val);
if(node->left) que.push(node->left);
if(node->right) que.push(node->right);
}
result.push_back(vec);
}
return result;
}
};