来说说二叉树非递归遍历

二叉树的遍历

早之前和同学聊天时，就提到了当时实习面试有一题就是要求非递归实现二叉树遍历，二叉树本身就是一种通过递归定义的数据结构，所以用递归的方法遍历二叉树是很容易的，而二叉树的遍历又分为前序遍历，中序遍历以及后序遍历，其中非递归的算法前序遍历和中序遍历稍简单，后序遍历稍复杂，并且都要用到栈，下面算法以如下二叉树为例：

则算法遍历的路线图如下所示：

前序遍历

前序遍历中，对于任一节点P可以看成根节点，它优先访问根节点，然后访问左孩子和右孩子。
对于P：
1. 访问P，把P入栈；
2. 若P的左孩子不为空，则使得P=P->left，回到操作1；
3. 若P的左孩子为空，则P=栈顶元素，栈顶元素出栈，P=P->right;

以节点B为例，则P=B，访问B，然后把B入栈，使得P=D,然后访问D并让D入栈，因为此时D的左孩子为空，则表示已到达最左的节点，需要回退，则D出栈，使得P=D->right，又因为D->right为空，继续回退，则B出栈，P=B->right，以此类推…

vector<int> preorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<TreeNode *> s;
        TreeNode * p = root;
        while(p!=NULL||!s.empty())
        {
            while(p!=NULL)
            {
                res.push_back(p->val);
                s.push(p);
                p = p->left;
            }
            p = s.top();
            s.pop();
            p = p->right;
        }
        return res;
    }

中序遍历

中序遍历访问节点的时机在从左孩子节点回退的时候，所以，
对于P：
1. 把P入栈；
2. 若P的左孩子不为空，则使得P=P->left，回到操作1；
3. 若P的左孩子为空，则P=栈顶元素，访问P，栈顶元素出栈，P=P->right;

vector<int> inorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<TreeNode *> s;
        TreeNode * p = root;
        while(p!=NULL||!s.empty())
        {
            while(p!=NULL)
            {
                s.push(p);
                p = p->left;
            }
            p = s.top();
            res.push_back(p->val);
            s.pop();
            p = p->right;

        }
        return res;
    }

后序遍历

由遍历的路线图可知，对于任一节点有三个访问时机，一次进入，两次回退（左孩子回退和右孩子回退），对于前序遍历，访问时机在进入时，对于中序遍历，访问时机在第一次回退，即左孩子回退时，对于后序遍历，访问时机在第二次回退，即右孩子回退时。
也正因为后序遍历存在两次回退，则需要加一个标志位，表示是否是第二次回退。
有人可能会问为什么中序遍历的第一次回退不需要加一个标志位标示是否是第一次回退了，因为这上面代码中回退以后，把该节点从栈中pop了，所以在代码中并不存在第二次回退。
对于P：
1. P的标志位置true，P入栈；
2. 若P的左孩子不为空，则使得P=P->left，P标志位置true，回到操作1；
3. 若P的左孩子为空，则P=栈顶元素，若P的标志位为true，则表示第一次回退，P标志位置false，使P=P->right；若P的标志位为false，则表示第二次回退，P出栈，并访问P；

vector<int> postorderTraversal(TreeNode *root) {
        vector<int> res;
        stack<pair<TreeNode *,int>>s;
        TreeNode *p = root;
        while(p!=NULL||!s.empty())
        {
            while(p)
            {
                s.push(pair<TreeNode*,int>(p,1));
                p = p->left;
            }
            pair<TreeNode*,int> q = s.top();
            s.pop();
            if(q.second==1)
            {
                s.push(pair<TreeNode*,int>(q.first,2));
                p = q.first->right;
            }
            else
            {
                res.push_back(q.first->val);
                p = NULL;
            }
        }
        return res;
    }