【LeetCode】【java】【树】binary-tree-preorder-traversal inorder postorder

题目

求给定的二叉树的前序遍历。
例如：
给定的二叉树为{1,#,2,3},
1↵ ↵ 2↵ /↵ 3↵
返回：[1,2,3].
备注；用递归来解这道题太没有新意了，可以给出迭代的解法么？

思路

1.二叉树的前序遍历–递归 ；迭代
2.对于递归 比较简单

代码

// 递归
import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        tranversal(root,res);
        return res;
    }
    void tranversal(TreeNode root,ArrayList<Integer> res){
        if(root!=null){
            res.add(root.val);
            tranversal(root.left,res);
            tranversal(root.right,res);
        }
        return;
    }
}

//迭代
import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public ArrayList<Integer> preorderTraversal(TreeNode root) {
        /*ArrayList<Integer> res = new ArrayList<Integer>();
        tranversal(root,res);
        return res;*/
        Stack<TreeNode> s = new Stack<TreeNode>();
        ArrayList<Integer> res = new ArrayList<Integer>();
         
        s.push(root);
        while(!s.isEmpty()){
            TreeNode p = s.pop();
            if(p==null){
                continue;
            }
            res.add(p.val);
            s.push(p.right);注意因为使用的是栈，所以应该先push right.
            s.push(p.left);
            
        }
        return res;
    }
    
    
    
    /*void tranversal(TreeNode root,ArrayList<Integer> res){
        if(root!=null){
            res.add(root.val);
            tranversal(root.left,res);
            tranversal(root.right,res);
        }
        return;
    }*/
}

---

中序遍历

import java.util.*;
/**
 * 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> res = new ArrayList<Integer>();
        generate(root,res);
        return res; 
    }
    void generate(TreeNode root,ArrayList<Integer> res){
        if(root!=null){
            generate(root.left,res);
            res.add(root.val);
            generate(root.right,res);
        }
        return;
    }*/
    public ArrayList<Integer> inorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode p = root;
        while(p!=null||!stack.isEmpty()){
            while(p!=null){
                stack.push(p);
                p=p.left;
            }
            p=stack.pop();
            res.add(p.val);
            p=p.right;
        }
        return res; 
    }
    
}

---

后序遍历

import java.util.*;
/**
 * Definition for binary tree
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    /*public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        generate(root,res);
        return res;
    }
    void generate(TreeNode root,ArrayList<Integer> res){
        if(root!=null){
            
            generate(root.left,res);
            generate(root.right,res);
            res.add(root.val);
        }
        return;
    }*/
    public ArrayList<Integer> postorderTraversal(TreeNode root) {
        ArrayList<Integer> res = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode t = null;
        while(root!=null||!stack.isEmpty()){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            
            root=stack.peek();
            if(root.right==null||root.right==t){
                res.add(stack.pop().val);
                t=root;
                root=null;
            }else{
                root=root.right;
            } 
        }
        
        return res;
    }
}

总结

stack 中 peek 和 pop的区别
相同点：大家都返回栈顶的值。

不同点：peek 不改变栈的值(不删除栈顶的值)，pop会把栈顶的值删除。