三种遍历方式-递归
144.二叉树的前序遍历
序，即中点所在的位置，前序即：中-左-右。
/**
* 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 preorder(TreeNode* node, vector<int> &arr)
{
if(node == nullptr) return;
// 终止条件
if(node->left == nullptr && node->right == nullptr)
{
arr.push_back(node->val);
return;
}
arr.push_back(node->val);
if(node->left != nullptr) preorder(node->left, arr);
if(node->right != nullptr) preorder(node->right, arr);
}
vector<int> preorderTraversal(TreeNode* root) {
// 前序遍历 中 - 左 - 右
std::vector<int> res{};
preorder(root, res);
return res;
}
};
94.二叉树的中序遍历
左-中-右。
/**
* 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 inorder(TreeNode* node, vector<int>& arr)
{
if(!node) return;
if(node->left == nullptr &&
node->right == nullptr)
{
arr.push_back(node->val);
return;
}
if(node->left) inorder(node->left, arr);
arr.push_back(node->val);
if(node->right) inorder(node->right, arr);
}
vector<int> inorderTraversal(TreeNode* root) {
// 中序 左-中-右
std::vector<int> res{};
inorder(root, res);
return res;
}
};
145.二叉树的后序遍历
左-右-中。
/**
* 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 postorder(TreeNode* node, vector<int>& arr)
{
if(!node) return;
if(node->left == nullptr &&
node->right == nullptr)
{
arr.push_back(node->val);
return;
}
if(node->left) postorder(node->left, arr);
if(node->right) postorder(node->right, arr);
arr.push_back(node->val);
}
vector<int> postorderTraversal(TreeNode* root) {
std::vector<int> res{};
postorder(root, res);
return res;
}
};
三种遍历方式-迭代
一入递归深入海，从此offer是路人。所以还是来迭代。
前序
利用栈的特性，逆序插入节点。(想不出来，抄随想录)
/**
* 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) {
std::stack<TreeNode*> st{};
std::vector<int> res{};
if(root == nullptr) return res;
TreeNode* node;
st.push(root);
while(!st.empty())
{
node = st.top();
if(node != NULL)
{
st.pop();
if(node->right) st.push(node->right);
if(node->left) st.push(node->left);
st.push(node);
st.push(NULL);
}
else
{
st.pop();
node = st.top();
st.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) {
std::vector<int> res{};
if(!root) return res;
std::stack<TreeNode*> st{};
TreeNode* node;
st.push(root);
while(!st.empty())
{
node = st.top();
res.push_back(node->val);
st.pop();
if(node->left) st.push(node->left);
if(node->right) st.push(node->right);
}
std::reverse(res.begin(),res.end());
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) {
vector<int> result;
stack<TreeNode*> st;
TreeNode* cur = root;
while (cur != NULL || !st.empty()) {
if (cur != NULL) { // 指针来访问节点，访问到最底层
st.push(cur); // 将访问的节点放进栈
cur = cur->left; // 左
} else {
cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
st.pop();
result.push_back(cur->val); // 中
cur = cur->right; // 右
}
}
return result;
}
};
