树的前序，中序，后序，层级非递归遍历

//============================================================================
// Name        : reversestring.cpp
// Author      : qxyu
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include<vector>
#include<algorithm>
#include<cmath>
#include<queue>
#include<map>
#include<stack>
#include<string>
#include<unordered_map>
//#include<uint32_t>
using namespace std;

/**
 * Definition for a point.
 */
struct Treenode{
	Treenode* left;
	Treenode* right;
	int val;
	Treenode(int x):val(x),left(NULL),right(NULL){}
};


vector<int> preorder(Treenode* root){
	vector<int> res;
	if(root == NULL) return res;
	res.push_back(root->val);
	preorder(root->left);
	preorder(root->right);
	return res;
}

vector<int> preorder_recursive(Treenode* root){
	vector<int> res;
	if(root == NULL) return res;
	stack<Treenode*> s;
	Treenode* t = root;

	while(t||!s.empty()){

		while(t){
				s.push(t);
				res.push_back(t->val);
				t=t->left;
			}

			t=s.top();
			s.pop();
			t=t->right;
	}
	return res;
}


vector<int> inorder_recursive(Treenode* root){
	vector<int> res;
	if(root==NULL) return res;
	stack<Treenode*> s;
	//vector<int> res;
	Treenode* t=root;
	while(t||!s.empty()){
		while(t){
			s.push(t);
			t=t->left;
		}


		t=s.top();
		res.push_back(t->val);
		s.pop();
		t=t->right;
	}
	return res;
}

vector<int> postorder(Treenode* root){
	vector<int> res;
	if(root == NULL) return res;
	stack<Treenode*> s;
		//vector<int> res;
		Treenode* t=root;
		int flag[20];
		while(t){
			s.push(t);
			flag[s.size()]=0;
			t=t->left;
		}

		while(!s.empty()){
			t=s.top();

				while(t&&t->right&&flag[s.size()]==0){
					t=t->right;
					flag[s.size()]=1;
					while(t){
						s.push(t);
						flag[s.size()]=0;
						t=t->left;
					}
				}

			t=s.top();
			res.push_back(t->val);
			s.pop();
		}
		return res;
}

vector<int> level_order(Treenode* root){
	vector<int> res;
	if(root == NULL) return res;
		queue<Treenode*> s;
			//vector<int> res;
			Treenode* t=root;
			s.push(t);
			while(!s.empty()){
				t=s.front();
				res.push_back(t->val);
				s.pop();
				if(t->left)
					s.push(t->left);
				if(t->right)
					s.push(t->right);
			}

			return res;
}
int main()
{
    Treenode* a=new Treenode(1);
    Treenode* b=new Treenode(2);
    Treenode* c=new Treenode(3);
    Treenode* d=new Treenode(4);
    Treenode* e=new Treenode(5);
    Treenode* f=new Treenode(5);
    Treenode* g=new Treenode(6);
    Treenode* h=new Treenode(6);
    Treenode* i=new Treenode(7);
    a->left=b;
    a->right=c;
    b->left=d;
    b->right=e;
    c->left=f;
    c->right=g;
    e->left=h;
    e->right=i;

    vector<int> v1=preorder_recursive(a);
    for(int i = 0; i < v1.size(); i ++)
    	cout<<v1[i]<<" ";
    cout<<endl;
    vector<int> v2=inorder_recursive(a);
        for(int i = 0; i < v1.size(); i ++)
        	cout<<v2[i]<<" ";
        cout<<endl;

        vector<int> v3=postorder(a);
            for(int i = 0; i < v3.size(); i ++)
            	cout<<v3[i]<<" ";
            cout<<endl;
            vector<int> v4=level_order(a);
                for(int i = 0; i < v4.size(); i ++)
                	cout<<v4[i]<<" ";
                cout<<endl;

}