目录
递归三要素：
- 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
- 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
- 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
题目链接：144. 二叉树的前序遍历-简单
题目描述：
给你二叉树的根节点 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 pre(TreeNode* cur, vector<int>& res){
if(cur == NULL)
return;
res.push_back(cur->val);
pre(cur->left, res);
pre(cur->right, res);
}
vector<int> preorderTraversal(TreeNode* root) {
vector<int> res;
pre(root, res);
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*> st;
vector<int> res;
if (root == NULL) return res;
st.push(root);
while (!st.empty()) {
TreeNode* cur = st.top(); // 中
st.pop();
res.push_back(cur->val);
if (cur->right) // 右
st.push(cur->right);
if (cur->left) // 左
st.push(cur->left);
}
return res;
}
};
题目链接：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* cur, vector<int>& res){
if(cur == NULL)
return;
post(cur->left, res);
post(cur->right, res);
res.push_back(cur->val);
}
vector<int> postorderTraversal(TreeNode* root) {
vector<int> res;
post(root, res);
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*> st;
vector<int> res;
if (root == NULL) return res;
st.push(root);
while (!st.empty()) {
TreeNode* cur = st.top(); // 中
st.pop();
res.push_back(cur->val);
if (cur->left) // 左
st.push(cur->left);
if (cur->right) // 右
st.push(cur->right);
}
reverse(res.begin(), res.end());
return res;
}
};
题目链接：94. 二叉树的中序遍历-简单
题目描述：
给定一个二叉树的根节点 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 in(TreeNode* cur, vector<int>& res){
if(cur == NULL)
return;
in(cur->left, res);
res.push_back(cur->val);
in(cur->right, res);
}
vector<int> inorderTraversal(TreeNode* root) {
vector<int> res;
in(root, res);
return res;
}
};
方法二：迭代法
那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了处理顺序和访问顺序是不一致的。
那么在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
代码如下：
/**
* 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> res;
stack<TreeNode*> st;
TreeNode* cur = root; // 根是否为空也会在while循环中做判断
while (cur != NULL || !st.empty()) {
if (cur != NULL) { // 指针来访问节点，访问到最底层
st.push(cur); // 将访问的节点放进栈
cur = cur->left; // 左
} else {
cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
st.pop();
res.push_back(cur->val); // 中
cur = cur->right; // 右，右若为空则在接下来的循环中判断，若不为空处理这棵子树
}
}
return res;
}
};