Leetcode二叉树的遍历方法.

二叉树的中序遍历算法.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */

给定二叉树，要求返回一个list，这个例子是二叉树的中序遍历结果。
正确答案：

class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer>res_list = new ArrayList<Integer>();
        Solution.MidTraverse(root,res_list);
        return res_list;
    }
    public static void MidTraverse(TreeNode root,List<Integer>res_list){
        if(root ==null) return;
        MidTraverse(root.left,res_list);
        res_list.add(root.val);
        MidTraverse(root.right,res_list);
    }
}

写完之后，发现最有启发的是怎么在leetcode的solution类中定义函数，以及如何初始化一个List，要用ArrayList链表方法。顺便复习一个arraylist的增删改查：

//遍历
Iterator<Integer> it = arrayList.iterator();
while(it.hasNext()){
    System.out.print(it.next() + " ");
} 
// .isEmpty()
arrayList.isEmpty() // 返回True/False
// .size() 
arrayList.size() // 返回int元素个数
// indexOf()
arrayList.indexOf() // 返回int索引编号
// get()
arrayList.get() //输入索引返回元素值
//remove
arrayList.remove()
// set
arrayList.set(int index, E element)

前序遍历的代码：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res_list= new ArrayList<Integer> ();
        Solution.PreTraverse(root, res_list);
        return res_list;
    }
    public static void PreTraverse(TreeNode root,List<Integer> res_list){
        if (root==null) return;
        res_list.add(root.val);
        PreTraverse(root.left,res_list);
        PreTraverse(root.right,res_list);
    }
}

后序遍历的代码：

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res_list= new ArrayList<Integer> ();
        Solution.LastTraverse(root, res_list);
        return res_list;
    }
    public static void LastTraverse(TreeNode root,List<Integer> res_list){
        if (root==null) return;
        LastTraverse(root.left,res_list);
        LastTraverse(root.right,res_list);
        res_list.add(root.val);
    }
}

可以看到从递归的角度实现二叉树的前、中、后序遍历并不难。如果从迭代的角度出发呢？