c++二叉树：层序，前，中，后 序遍历的解题模板

若是记住一些解题套路，则在求解关于二叉树的题型时，直接套用模板，加快解题速度。

节点定义

/*节点定义*/
class Node {//节点定义
public:
    int val;
    Node* left;
    Node* right;

    Node() {}//默认无参构造函数
    Node(int _val) {//带数据值的构造函数
        val = _val; left = NULL;right = NULL;
    }
    Node(int _val, Node* _left, Node* _right) {//有数据，有左子树，有右子树的构造函数
        val = _val;  left = _left;right = _right;
    }
};

一、层序遍历：第一层点,第二层节点,…,第n层节点

void Sequence_traversal(Node* root) {
		if (!root)return ;
		Node* p ;
		deque<Node*>deq;//这里用queue其实完全足够（参照Sequence_traversal2），这里只是扩展知识，多熟悉一下知识。
		deq.push_back(root);
		while (!deq.empty()) {
			p = deq.front();
			deq.pop_front();
			if(p)cout << p->val << " ";
			//else cout << "null ";
			if (p)deq.push_back(p->left);
			if (p)deq.push_back(p->right);
		}
}

//或者：
void Sequence_traversal_2(Node* root) {
		if (!root)return ;
        queue<Node*> q;
        q.push(root);
        int ans = 0;
        while (!q.empty()) {
            for (int i = q.size() - 1; i >= 0; --i) {
                Node* cur = q.front();
                cout << cur->val << " ";
                q.pop();
                if (cur->left) q.push(cur->left);
                if (cur->right) q.push(cur->right);
            }
            ++ans;
        }
        cout<<"层数: "<<ans<<endl;
    }

二、前序（先序）遍历：父节点-左子树-右子树

//方法一：非递归   前序：父节点-左子树-右子树
void  preorder_traversal (Node* root) {
		if (!root)return ;
		Node* p = root;
		stack<Node*> st;
		st.push(p);
		//前序遍历的模板： 父节点-左子树-右子树
		while (!st.empty()) {//父节点-左子树-右子树		
			p = st.top();			
			st.pop();
			cout << p->val << " ";
			if (p->right)st.push(p->right);
			if (p->left)st.push(p->left);	
		}
}

//方法二：递归     前序：父节点-左子树-右子树
void  preorder_traversal (Node* root) {
		if (!root)return ;
		cout<<root->val<<" ";//父
		st.push(p->left);	//左
		st.push(p->right);  //右
		
}

三、中序遍历：左子树-父节点-右子树

//方法一：非递归方法。中序遍历：左子树-父节点-右子树

void inorder_traversal(Node* root) {
		if (!root)return ;
		Node* p = root;
		stack<Node*> st;
		while (p||!st.empty()) {
			while (p) {
				st.push(p);
				p= p->left;
			}
			if(!st.empty()) {
				p = st.top();
				st.pop();
				cout << p->val << " ";
				p = p->right;
			}
		}
}

//方法二：递归    中序遍历：左子树-父节点-右子树

void inorder_traversal(Node* root) {
		if (!root)return ;
		inorder_traversal(root->left) ;//左
		cout<<root->val<<" ";		   //父
		inorder_traversal(root->right) ;//右
}

四、后序遍历：左子树-右子树-父节点

//方法一：非递归方法。后序遍历，左子树-右子树-父节点
void postorder_traversal(Node* root) {
		if (!root)return ;
		Node* p = root;
		stack<Node*> st;
		stack<Node*> out_sta;
		while (p || !st.empty()) {
			if (p) {
				out_sta.push(p);//
				st.push(p);
				p = p->right;
			}
			else {					
					p = st.top();
					st.pop();
					p = p->left;
				}
			}
		while(!out_sta.empty()){
					cout << out_sta.top()->val << " ";;
					out_sta.pop();
		}
}

//方法二：递归。后序遍历，左子树-右子树-父节点
void postorder_traversal(Node* root) {
		if (!root)return ;
		postorder_traversal(root->left);//左
		postorder_traversal(root->right);//右
		cout<<root->val<<" ";           //父
}