【LeetCode】144.二叉树的前序遍历
题意:给你二叉树的根节点 root ,返回它节点值的 前序 遍历。
思路:递归根左右。迭代用栈,实际出栈顺序上左右要颠倒。
代码A:
/**
* 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 pre(TreeNode *root, vector<int> &order)
{
if (!root)
{
return;
}
order.push_back(root->val);
pre(root->left, order);
pre(root->right, order);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
pre(root, res);
return res;
}
};
代码B:
/**
* 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<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
{
return res;
}
stk.push(root);
while (!stk.empty())
{
TreeNode* node = stk.top();
stk.pop();
res.push_back(node->val);
if (node->right)
{
stk.push(node->right);
}
if (node->left)
{
stk.push(node->left);
}
}
return res;
}
};
【LeetCode】145.二叉树的后序遍历
题意:给你一棵二叉树的根节点 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:
void post(TreeNode* root, vector<int> &order)
{
if (!root)
{
return;
}
post(root->left, order);
post(root->right, order);
order.push_back(root->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
post(root, res);
return res;
}
};
代码B:
/**
* 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<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
{
return res;
}
stk.push(root);
while (!stk.empty())
{
TreeNode* node = stk.top();
stk.pop();
res.push_back(node->val);
if (node->left)
{
stk.push(node->left);
}
if (node->right)
{
stk.push(node->right);
}
}
reverse(res.begin(), res.end());
return res;
}
};
【LeetCode】94.二叉树的中序遍历
题意:给定一个二叉树的根节点 root ,返回 它的 中序 遍历 。
思路:递归左根右。迭代访问的元素和要处理的元素顺序是不一致的,访问从根开始,处理要最左边开始,所以用栈存储直到最左边,然后用指针来记录访问顺序。当没有左孩子时,处理中间,然后去右边。
代码A:
/**
* 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 in(TreeNode* root, vector<int> &order)
{
if (!root)
{
return;
}
in(root->left, order);
order.push_back(root->val);
in(root->right, order);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
in(root, res);
return res;
}
};
代码B:
/**
* 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<int> inorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
TreeNode* cur = root;
while (cur || !stk.empty())
{
if (cur)
{
stk.push(cur);
cur = cur->left;
}
else
{
cur = stk.top();
stk.pop();
res.push_back(cur->val);
cur = cur->right;
}
}
return res;
}
};
还有一种统一法写迭代,用空指针做操作标记太强了,迭代变成默写题
前序:
/**
* 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<int> preorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
{
return res;
}
stk.push(root);
while (!stk.empty())
{
TreeNode* node = stk.top();
if (node)
{
// 中左右->右左中
stk.pop();
if (node->right)
{
stk.push(node->right);
}
if (node->left)
{
stk.push(node->left);
}
stk.push(node);
stk.push(NULL);
}
else
{
stk.pop();
TreeNode *node = stk.top();
stk.pop();
res.push_back(node->val);
}
}
return res;
}
};
中序:
/**
* 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<int> inorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
{
return res;
}
stk.push(root);
while(!stk.empty())
{
TreeNode *node = stk.top();
// 左中右->右中左
if (node)
{
stk.pop();
if (node->right)
{
stk.push(node->right);
}
stk.push(node);
stk.push(NULL);
if (node->left)
{
stk.push(node->left);
}
}
else
{
stk.pop();
node = stk.top();
stk.pop();
res.push_back(node->val);
}
}
return res;
}
};
后序:
/**
* 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<int> postorderTraversal(TreeNode* root) {
stack<TreeNode*> stk;
vector<int> res;
if (!root)
{
return res;
}
stk.push(root);
while (!stk.empty())
{
TreeNode* node = stk.top();
if (node)
{
// 左右中->中右左
stk.pop();
stk.push(node);
stk.push(NULL);
if (node->right)
{
stk.push(node->right);
}
if (node->left)
{
stk.push(node->left);
}
}
else
{
stk.pop();
node = stk.top();
stk.pop();
res.push_back(node->val);
}
}
return res;
}
};
心态:“第六章 二叉树part01” 拿下!
参考资料