二叉树先序、中序、后序遍历的递归与非递归实现以及层次遍历。
#include<iostream>
#include<vector>
#include<stack>
#include<queue>
using namespace std;
vector<vector<int>> res;
vector<int> help;
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int value) :val(value), left(nullptr), right(nullptr){}
};
void insertNode(TreeNode *root,int &value){//构建搜索二叉树,左子节点的值小于等于根节点的值,右子节点的值大于等于根节点的值
if (value<=root->val){//小了往左边插入
if (!root->left){
root->left = new TreeNode(value);
}
else{
insertNode(root->left,value);
}
}
else{//大了往右边插入
if (!root->right){
root->right = new TreeNode(value);
}
else{
insertNode(root->right, value);
}
}
}
void preOrder(TreeNode* root){//非递归实现先序遍历
stack<TreeNode*> nstack;
nstack.push(root);
while (!nstack.empty()){
TreeNode* tmp = nstack.top();
help.push_back(tmp->val);
nstack.pop();
if (tmp->right){//栈是先进后出的,因此先入右节点,后入左节点。
nstack.push(tmp->right);
}
if (tmp->left){
nstack.push(tmp->left);
}
}
res.push_back(help);
help.clear();
}
void preOrder1(TreeNode* root){//递归实现先序遍历
if (root){
help.push_back(root->val);
preOrder1(root->left);
preOrder1(root->right);
}
}
void midOrder(TreeNode* root){//非递归实现中序遍历
stack<TreeNode*> nstack;
TreeNode* tmp = root;
while (tmp || !nstack.empty()){
if (tmp){
nstack.push(tmp);
tmp = tmp->left;
}
else{
tmp = nstack.top();
help.push_back(tmp->val);
nstack.pop();
tmp = tmp->right;
}
}
res.push_back(help);
help.clear();
}
void midOrder1(TreeNode* root){//递归实现中序遍历
if (root){
midOrder1(root->left);
help.push_back(root->val);
midOrder1(root->right);
}
}
void postOrder(TreeNode* root){//非递归实现后序遍历(特殊,两个栈实现)
stack<TreeNode*> nstack1, nstack2;
nstack1.push(root);
while (!nstack1.empty()){
TreeNode* tmp = nstack1.top();
nstack1.pop();
nstack2.push(tmp);//借助栈1实现栈2入栈顺序:根、右、左;最后出栈就是后序遍历顺序
if (tmp->left){
nstack1.push(tmp->left);
}
if (tmp->right){
nstack1.push(tmp->right);
}
}
while (!nstack2.empty()){
TreeNode* tmp = nstack2.top();
help.push_back(tmp->val);
nstack2.pop();
}
res.push_back(help);
help.clear();
}
void postOrder1(TreeNode* root){//递归实现后序遍历
if (root){
postOrder1(root->left);
postOrder1(root->right);
help.push_back(root->val);
}
}
void bfsOrder(TreeNode* root){//层次遍历(使用队列实现--先进先出)
queue<TreeNode*> nqueue;
nqueue.push(root);
while (!nqueue.empty()){
TreeNode *tmp = nqueue.front();
help.push_back(tmp->val);
nqueue.pop();
if (tmp->left){
nqueue.push(tmp->left);
}
if (tmp->right){
nqueue.push(tmp->right);
}
}
res.push_back(help);
help.clear();
}
vector<vector<int> > fourOrders(TreeNode* root) {
if (root == nullptr)
return res;
preOrder1(root);
midOrder1(root);
postOrder1(root);
bfsOrder(root);
return res;
}
int main(){
int n;
while (cin >> n){
n--;
int value;
cin >> value;
TreeNode root(value);
while (n--){
int newValue;
std::cin >> newValue;
insertNode(&root, newValue);
}
fourOrders(&root);
for (int i = 0; i < res.size();++i){
for (int j = 0; j < res[j].size(); ++j){
cout << res[i][j];
}
cout << endl;
}
}
return 0;
}