遍历二叉树的迭代写法

使用递归遍历二叉树一般比较简单，使用迭代较难。这两种方法是等价的，不同之处在于递归时隐式维护了一个栈，而迭代时则要显示地将这个栈模拟出来。

1.前序遍历
前序遍历时中左右的遍历顺序，处理时先将根节点压入栈中，然后处理根节点，将右孩子先压入栈中，再将左孩子压入栈中(处理时先左后右，故入栈顺序为先右后左)

 vector<int> preorderTraversal(TreeNode* root){
 	stack<TreeNode*> stk;
 	vector<int> res;
	
	if(root == NULL) return res;
	stk.push(root);
	while(!stk.empty()){
		TreeNode *node = stk.top();
		res.push_back(node->value);//中
		stk.pop();
		
		if(node->right) stk.push(node->right);//先进右，处理时后处理右
		if(node->left) stk.push(node->left);//后进左，处理时先处理左
	}
	return res;
 }
 

2.后序遍历
后序遍历访问顺序为左右中，观察其与前序遍历(中左右)的区别，可以发现，先改变前序中的部分代码得到中右左的顺序，然后将vector逆序即可

 vector<int> postorderTraversal(TreeNode* root){
 	stack<TreeNode*> stk;
 	vector<int> res;
	
	if(root == NULL) return res;
	stk.push(root);
	while(!stk.empty()){
		TreeNode *node = stk.top();
		res.push_back(node->value);
		stk.pop();
		
		if(node->left) stk.push(node->left);//在此处更改，实现中右左的顺序
		if(node->right) stk.push(node->right);
		
	}
	reverse(result.begin(), result.end());//调整顺序
	return res;
 }
 

3.中序遍历
中序遍历与前两种没有较好的统一写法，这是由于前两种遍历，访问的结点和要处理的结点是同一个。而中序不是，先访问的是根节点，而先处理的是左孩子。

vector<int> inorderTraversal(TreeNode* root) {
	vector<int> res;
	stack<TreeNode*> stk;

	TreeNode *node = root;
	while(node!=NULL||!stk.empty()){
	
		if(node != NULL){
			stk.push(node);
			node = node->left;//左
		}else{
			node = stk.top();
			stk.pop();
			res.push_back(node->value);//中
			node = node -> right;//右
		}
	}
	return res;
}

4.三种顺序的统一写法

三种遍历顺序写法不同，主要原因在于访问的结点和处理的结点有时是同一个，有时不是同一个，解决这个问题的方法是：
将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。

中序遍历

vector<int> inorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        if (root != NULL) stk.push(root);//先压根结点入栈
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            if (node != NULL) {
                stk.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
                if (node->right) stk.push(node->right);  // 添加右节点（空节点不入栈）

                stk.push(node);                          // 添加中节点
                stk.push(NULL); // 中节点访问过，但是还没有处理，加入空节点做为标记。

                if (node->left) stk.push(node->left);    // 添加左节点（空节点不入栈）
            } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
                stk.pop();           // 将空节点弹出
                node = stk.top();    // 重新取出栈中元素
                stk.pop();
                res.push_back(node->val); // 加入到结果集
            }
        }
        return res;
    }

前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        if (root != NULL) stk.push(root);
        while (!stk.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                stk.pop();
                if (node->right) stk.push(node->right);  // 右
                if (node->left) stk.push(node->left);    // 左
                stk.push(node);                          // 中
                stk.push(NULL);
            } else {
                stk.pop();
                node = st.top();
                stk.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};

后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> res;
        stack<TreeNode*> stk;
        if (root != NULL) st.push(root);
        while (!stk.empty()) {
            TreeNode* node = stk.top();
            if (node != NULL) {
                stk.pop();
                stk.push(node);                          // 中
                stk.push(NULL);

                if (node->right) stk.push(node->right);  // 右
                if (node->left) stk.push(node->left);    // 左

            } else {
                stk.pop();
                node = st.top();
                stk.pop();
                res.push_back(node->val);
            }
        }
        return res;
    }
};