leetcode中二叉树的遍历

整理一下...

1. 前序遍历

leetcode: 144. Binary Tree Preorder Traversal 

(1) 递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        
        List<Integer> tree = new ArrayList<Integer>();
        traversal(tree, root);
        return tree;
        
    }
    
    public void traversal(List<Integer> tree, TreeNode root){
        if(root!=null){
            tree.add(root.val);
            traversal(tree, root.left);
            traversal(tree, root.right);
        }
    }
}

(2)非递归法（利用Stack）

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> tree = new ArrayList<Integer>();
        Stack<TreeNode> myStack = new Stack<TreeNode>();
        if(root==null) return tree;
        else myStack.push(root);
        
        while(!myStack.empty()){
            TreeNode cur = myStack.pop();
            tree.add(cur.val);
            if(cur.right!=null) myStack.push(cur.right);
            if(cur.left!=null) myStack.push(cur.left);
        }
        
        return tree;
    }
}

2. 中序遍历

94. Binary Tree Inorder Traversal

（1）递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> tree = new ArrayList<Integer>();
        traversal(tree, root);
        return tree;
    }
    
    public void traversal(List<Integer> tree, TreeNode root){
        if(root!=null){
            traversal(tree, root.left);
            tree.add(root.val);
            traversal(tree, root.right);
    }
}

（2）非递归法

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

3. 后序遍历

145. Binary Tree Postorder Traversal

（1）递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> tree = new ArrayList<Integer>();
        traversal(tree, root);
        return tree;
    }
    
    public void traversal(List<Integer> tree, TreeNode root){
        if(root!=null){
            traversal(tree, root.left);
            traversal(tree, root.right);
            tree.add(root.val);
    }
}

（2）非递归法

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> tree = new ArrayList<Integer>();
    if(root == null) return tree;
    
    Stack<TreeNode> myStack = new Stack<TreeNode>();
    myStack.push(root);
    while (!stack.empty()) {
        TreeNode node = myStack.pop();
        tree.add(0, node.val);//每次都将元素插入到list的最开始位置，方法很简洁
        if (node.left != null) stack.push(node.left);
        if (node.right != null) stack.push(node.right);
        }
    return tree;
  }
}

还有一种双栈法，和上面的思路相同，通过双栈将前序转化为后序：

public class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
    List<Integer> tree = new ArrayList<Integer>();
    if(root == null) return tree;
    
    Stack<TreeNode> stack1 = new Stack<TreeNode>();
    Stack<TreeNode> stack2 = new Stack<TreeNode>();
    stack1.push(root);
    while (!stack1.empty()) {
        TreeNode cur = stack1.pop();
        stack2.push(cur);
        if(cur.left!=null) stack1.push(cur.left);
        if(cur.right!=null) stack1.push(cur.right);
    }
    
    while(!stack2.empty()){
        TreeNode cur = stack2.pop();
        tree.add(cur.val);
    }
    return tree;
  }
}