二叉树的递归遍历和非递归(迭代)遍历C++实现
二叉树的递归遍历和非递归遍历C++代码实现
- 递归算法
- 非递归算法（迭代算法）
- 总结
这里先给出二叉树的实现代码
struct TreeNode {
int val;
TreeNode* left;
TreeNode* right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
递归算法
前序遍历（先根遍历）
void preorderTraversal(TreeNode* root)
{
if(root==NULL)
return;
cout<<root->val<<endl;
preorderTraversal(root->left);
preorderTraversal(root->right);
}
完整测试代码：
#include测试案例：
运行结果：
中序遍历（中根遍历）
void inorderTraversal(TreeNode* root)
{
if(root==NULL)
return;
inorderTraversal(root->left);
cout<<root->val<<endl;
inorderTraversal(root->right);
}
完整代码实现：
#include测试案例：
运行结果：
后序遍历（后根遍历）
void postorderTraversal(TreeNode* root)
{
if(root==NULL)
return;
postorderTraversal(root->left);
postorderTraversal(root->right);
cout<<root->val<<endl;
}
完整代码实现：
#include测试案例：
运行结果：
非递归算法（迭代算法）
在非递归算法中，中序遍历相比先序遍历和后序遍历较简单，这里先将中序遍历的非递归算法。
中序遍历（中根遍历）
vector<int> inorderTraversal(TreeNode* root) {
vector<int> ans;
stack<TreeNode*> s;
TreeNode* p = root;
while (p != NULL || !s.empty())
{
if (p != NULL)
{
s.push(p);
p = p->left;
}
else
{
p = s.top();
s.pop();
ans.push_back(p->val);
p = p->right;
}
}
return ans;
}
先序遍历（先根遍历）
vector<int> preorderTraversal(TreeNode* root) {
vector<int> ans;
struct Treep
{
struct TreeNode* ptr;
int flag;
};
stack<Treep> s;
if (root == NULL)
return ans;
Treep p, tmp;
p.ptr = root;
p.flag = 0;
s.push(p);
while (!s.empty())
{
p = s.top();
s.pop();
if (p.flag == 0)
{
ans.push_back(p.ptr->val);
tmp = p;
tmp.flag++;
s.push(tmp);
if (p.ptr->left != NULL)
{
tmp.ptr = p.ptr->left;
tmp.flag = 0;
s.push(tmp);
}
}
else if (p.flag == 1)
{
tmp = p;
tmp.flag++;
s.push(tmp);
if (p.ptr->right != NULL)
{
tmp.ptr = p.ptr->right;
tmp.flag = 0;
s.push(tmp);
}
}
}
return ans;
}
完整代码代码：
#include后序遍历（后根遍历）
vector<int> postorderTraversal(TreeNode* root) {
struct Treep
{
TreeNode* ptr;
int flag;
};
stack<Treep> s;
vector<int> ans;
if (root == NULL)
return ans;
Treep p;
p.ptr = root;
p.flag = 0;
s.push(p);
while (!s.empty())
{
p = s.top();
s.pop();
if (p.flag == 0)
{
Treep tmp;
tmp.ptr = p.ptr;
tmp.flag = p.flag + 1;
s.push(tmp);
if (p.ptr->left != NULL)
{
tmp.ptr = p.ptr->left;
tmp.flag = 0;
s.push(tmp);
}
}
else if (p.flag == 1)
{
Treep tmp;
tmp.ptr = p.ptr;
tmp.flag = p.flag + 1;
s.push(tmp);
if (p.ptr->right != NULL)
{
tmp.ptr = p.ptr->right;
tmp.flag = 0;
s.push(tmp);
}
}
else
{
ans.push_back(p.ptr->val);
}
}
return ans;
}
完整代码实现：
#include总结
1.递归算法相对简单，但是但是但是很容易超时！！！刷题基本过不了。
2.递归虽然相对复杂，用到了栈，但是稳点，不容易爆。
3.刷oj当然是选非递归算法（迭代），递归算法平时跑点简单的代码还是没问题的。