Binary Tree Inorder Traversal - LeetCode

Given a binary tree, return the inorder traversal of its nodes' values.

For example:
Given binary tree {1,#,2,3},

   1
    \
     2
    /
   3

return [1,3,2].

Note: Recursive solution is trivial, could you do it iteratively?

这道题和另外一道树的遍历基本相似。我写的代码如下（已AC）。

/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> lst = new ArrayList<Integer>(); 
		if(root == null)  
			return lst;
		Stack<TreeNode> stack = new Stack<TreeNode>(); 
		TreeNode p = root;
		while(p!=null||!stack.empty()){
			while(p != null){
				stack.push(p);
				p = p.left;
			}
			if(!stack.empty()){
				p = stack.pop();
				lst.add(p.val);
				p = p.right;
			}
		}
		return lst;
    }
}

这里再考虑一下二叉树的非递归遍历。

先推荐一篇关于此的文章： http://www.cnblogs.com/dolphin0520/archive/2011/08/25/2153720.html

有关非递归的中序遍历，解释如下：

根据中序遍历的顺序，对于任一结点，优先访问其左孩子，而左孩子结点又可以看做一根结点，然后继续访问其左孩子结点，直到遇到左孩子结点为空的结点才进行访问，然后按相同的规则访问其右子树。因此其处理过程如下：

   对于任一结点P，

  1)若其左孩子不为空，则将P入栈并将P的左孩子置为当前的P，然后对当前结点P再进行相同的处理；

  2)若其左孩子为空，则取栈顶元素并进行出栈操作，访问该栈顶结点，然后将当前的P置为栈顶结点的右孩子；

  3)直到P为NULL并且栈为空则遍历结束

void inOrder2(BinTree *root)      //非递归中序遍历
{
    stack<BinTree*> s;
    BinTree *p=root;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)
        {
            s.push(p);
            p=p->lchild;
        }
        if(!s.empty())
        {
            p=s.top();
            cout<<p->data<<" ";
            s.pop();
            p=p->rchild;
        }
    }    
}

其中主要的步骤为：

1、检验目前节点是否为空或者整个栈已为空，若两者皆空则停止整个循环。

2、若目前节点不为空，说明还可以继续遍历，将当前节点入栈，并设置为此节点的左孩子为current。一直从左走到底。

3、一个节点从左走到底之后，若栈不为空则从栈顶出一个节点，然后输出这个节点，再将其右侧节点设置为当前节点。

对于前序列遍历，

1、检验目前节点是否为空或者整个栈已为空，若两者皆空则停止整个循环。

2、若目前节点不为空，说明还可以继续遍历，将当前节点入栈、输出，并设置为此节点的左孩子为current。一直从左走到底。

3、一个节点从左走到底之后，若栈不为空则从栈顶出一个节点（一定要pop出来，否则会一直循环无法退出），再将其右侧节点设置为当前节点。

对于这两种遍历，最不一样的就是输出的位置，只需要改变输出的位置再用同样的算法步骤就可以实现这两种遍历了。

后序遍历的非递归实现是三种遍历方式中最难的一种。因为在后序遍历中，要保证左孩子和右孩子都已被访问并且左孩子在右孩子前访问才能访问根结点，这就为流程的控制带来了难题。下面介绍两种思路。


第一种思路：对于任一结点P，将其入栈，然后沿其左子树一直往下搜索，直到搜索到没有左孩子的结点，此时该结点出现在栈顶，但是此时不能将其出栈并访问，因此其右孩子还为被访问。所以接下来按照相同的规则对其右子树进行相同的处理，当访问完其右孩子时，该结点又出现在栈顶，此时可以将其出栈并访问。这样就保证了正确的访问顺序。可以看出，在这个过程中，每个结点都两次出现在栈顶，只有在第二次出现在栈顶时，才能访问它。因此需要多设置一个变量标识该结点是否是第一次出现在栈顶。

这种思路是推荐思路，代码如下：

void postOrder2(BinTree *root)    //非递归后序遍历
{
    stack<BTNode*> s;
    BinTree *p=root;
    BTNode *temp;
    while(p!=NULL||!s.empty())
    {
        while(p!=NULL)              //沿左子树一直往下搜索，直至出现没有左子树的结点 
        {
            BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
            btn->btnode=p;
            btn->isFirst=true;
            s.push(btn);
            p=p->lchild;
        }
        if(!s.empty())
        {
            temp=s.top();
            s.pop();
            if(temp->isFirst==true)     //表示是第一次出现在栈顶 
             {
                temp->isFirst=false;
                s.push(temp);
                p=temp->btnode->rchild;    
            }
            else                        //第二次出现在栈顶 
             {
                cout<<temp->btnode->data<<" ";
                p=NULL;
            }
        }
    }    
}

第二种思路：要保证根结点在左孩子和右孩子访问之后才能访问，因此对于任一结点P，先将其入栈。如果P不存在左孩子和右孩子，则可以直接访问它；或者P存在左孩子或者右孩子，但是其左孩子和右孩子都已被访问过了，则同样可以直接访问该结点。若非上述两种情况，则将P的右孩子和左孩子依次入栈，这样就保证了每次取栈顶元素的时候，左孩子在右孩子前面被访问，左孩子和右孩子都在根结点前面被访问。

这种思路就不详解了，如果有兴趣可以参看我之前推荐链接里的文章。