leetcode-94-二叉树的中序遍历（binary tree inorder traversal）-java

题目及测试

package pid094;

import java.util.List;

/*中序遍历二叉树

给定一个二叉树，返回它的中序 遍历。

示例:

输入: [1,null,2,3]
   1
    \
     2
    /
   3

输出: [1,3,2]

进阶: 递归算法很简单，你可以通过迭代算法完成吗？



}*/
public class main {
	
	public static void main(String[] args) {
		Integer[] x=new Integer[]{1,null,2,null,null,3,null};	
		BinaryTree tree=new BinaryTree(x);
		tree.printTree(tree.root);
		test(tree.root);
		
		
		
	}
		 
	private static void test(TreeNode ito) {
		Solution solution = new Solution();
		List rtn;
		long begin = System.currentTimeMillis();
		rtn = solution.inorderTraversal(ito);//执行程序
		for(Integer num:rtn){
			System.out.println(num+" ");
		}

		System.out.println();
		System.out.println("-------------------");
	}

}

解法1（成功，2ms，较慢）

使用循环的方法，建立一个栈，将root放进去，每次取出栈的头部now
当栈不为空时进行循环
如果now没有左右子树，说明遍历已经到最深处，则把now的值加入list
如果有左右子树，则首先把右子树取出，放入栈顶，然后now。right=null，切断now与右子树的关系，不然待会会重复计算now的右子树
然后放入now
最后方入左子树，now。left=null

package pid094;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
	//先中序遍历左子树，再根，再右子树
    public List inorderTraversal(TreeNode root) {
        Stack stack=new Stack<>();
        List result=new ArrayList<>();
        if(root==null){
        	return result;
        }
        stack.add(root);
        while(!stack.isEmpty()){
        	TreeNode now=stack.pop();
        	if(now.left==null&&now.right==null){
        		result.add(now.val);
        		continue;
        	}
        	if(now.right!=null){
        		stack.add(now.right);
        		now.right=null;
        	}
        	stack.add(now);
        	if(now.left!=null){
        		stack.add(now.left);
        		now.left=null;
        	}
        }       
    	return result;
    }
}

解法2（别人的）

同样用栈，用循环，解法比我的高明

循环条件是curt不为null或者stack不为空
首先将curt自身及所有左子树逐个加入stack
然后弹出stack顶部，将其加入result
最后curt为弹出的那个节点的右子树
因为弹出的那个节点，左子树要么没有，要么已经被处理，所以只考虑右子树
右子树如果没有，则下一次循环，直接curt = stack.pop();，相当于处理它的上层
如果有右子树，那么先处理该节点的右子树，再处理上层

public class Solution {
    /**
     * @param root: The root of binary tree.
     * @return: Inorder in ArrayList which contains node values.
     */
    public ArrayList inorderTraversal(TreeNode root) {
        Stack stack = new Stack();
        ArrayList result = new ArrayList();
        TreeNode curt = root;
        while (curt != null || !stack.empty()) {
            while (curt != null) {
                stack.add(curt);
                curt = curt.left;
            }
            curt = stack.pop();
            result.add(curt.val);
            curt = curt.right;
        }
        return result;
    }
}

解法3（成功，1ms，递归）

    public List inorderTraversal(TreeNode root) {
        List result=new ArrayList<>();
        if(root!=null){
        	inorder(result, root);    
        }       	   	
    	return result;
    }	
	
	public void inorder(List result,TreeNode root){
		if(root.left!=null){
			inorder(result, root.left);
		}
		result.add(root.val);
		if(root.right!=null){
			inorder(result, root.right);
		}
	}