java实现树的先序、中序、后序、层序遍历（递归、迭代版本）

一、树的定义（类）

1.二叉树

/**
 * 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;
 *     }
 * }
 */

2.N叉树

/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

二、先序遍历（根左右）

1.二叉树

//递归
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        dfs(root, res);
        return res;
    }
    public void dfs(TreeNode root, List<Integer> list){
        if(root == null) return;
        list.add(root.val);
        dfs(root.left, list);
        dfs(root.right, list);
    }
}

 //迭代
class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Stack<TreeNode> st = new Stack<>();
        st.push(root);
        while(!st.empty()){
            TreeNode node = st.pop();
            res.add(node.val);
            //注意后进先出，先放入右子树，后左子树
            if(node.right != null) st.add(node.right);
            if(node.left != null) st.add(node.left);
        }
        return res;
    }
}

2.N叉树

//递归
class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        dfs(root, res);
        return res;
    }
    public void dfs(Node root, List<Integer> list){
        if(root == null) return;
        list.add(root.val);
        for(Node x:root.children){
            dfs(x, list);
        }
    }
}

//迭代
class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Stack<Node> s = new Stack<>();
        s.push(root);
        while(!s.empty()){
            Node node = s.pop();
            res.add(node.val);
            for(int i = node.children.size() - 1; i >= 0; i --){
                if(node.children.get(i) != null) s.push(node.children.get(i));
            }
        }
        return res;
    }
}

三、中序遍历（左根右）

//递归
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        dfs(root, res);
        return res;
    }
    public void dfs(TreeNode root, List<Integer> list){
        if(root == null) return;
        dfs(root.left, list);
        list.add(root.val);
        dfs(root.right, list);
    }
}

//迭代
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> s = new Stack<>();
        while(root != null || !s.empty()){
            //访问最左子树
            while(root != null){
                s.push(root);
                root = root.left;
            }
            //取出当前节点
            TreeNode cur = s.pop();
            res.add(cur.val);
            //访问当前节点的右子树
            root = cur.right;
        }
        return res;
    }
}

四、后序遍历（左右根）

1.二叉树

//递归
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        dfs(root, res);
        return res;
    }
    public void dfs(TreeNode root, List<Integer> list){
        if(root == null) return;
        dfs(root.left, list);
        dfs(root.right, list);
        list.add(root.val);
    }
}

//迭代
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Stack<TreeNode> s = new Stack<>();
        TreeNode last = null;
        while(root != null || !s.empty()){
            //寻找最左子树
            while(root != null){
                s.push(root);
                root = root.left;
            }
            TreeNode cur = s.peek();
            /*与中序的不同之处在于：中序遍历中，从栈中弹出的节点，
            其左子树是访问完了，可以直接访问该节点，然后接下来访问右子树。
            后序遍历中，从栈中弹出的节点，我们只能确定其左子树肯定访问完了，
            但是无法确定右子树是否访问过。
            因此，在后序遍历中，引入了一个last来记录上一次访问记录。
            */
            //判断是否访问当前节点的右子树
            if(cur.right != null && cur.right != last){
                //右子树存在，且没有被访问过
                root = cur.right;
            }else{
                res.add(cur.val);
                s.pop();
                last = cur;
                root = null;
            }
        }
        return res;
    }
}

2.N叉树

//递归
class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> res = new ArrayList<>();
        dfs(root, res);
        return res;
    }
    public void dfs(Node root, List<Integer> list){
        if(root == null) return;
        for(Node x : root.children) dfs(x, list);
        list.add(root.val);
    }
}

//迭代
class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> res = new ArrayList<>();
        if(root == null) return res;
        Stack<Node> s = new Stack<>();
        //维护一个指针pre，用于记录上一个访问的节点
        Node pre = null;    
        while(root != null || !s.empty()){
            while(root != null){
                s.push(root);
                if(root.children.size() == 0) break;
                root = root.children.get(0);
            }
            Node temp = s.peek();
            if(temp.children.size() == 0 || pre == temp.children.get(temp.children.size() - 1)){
                //没有儿子或儿子已经全部访问完毕，访问当前节点
                Node node = s.pop();
                res.add(node.val);
                pre = node;
                root = null;
            }else{
                //有儿子，访问下一个儿子，索引为pre的索引+1
                root = temp.children.get(temp.children.indexOf(pre) + 1);
            }
        }
        return res;
    }
}

五、层序遍历（BFS）

1.二叉树

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()){
            List<Integer> temp = new ArrayList<>();
            int size = q.size();
            while(size -- > 0){
                TreeNode node = q.poll();
                temp.add(node.val);
                if(node.left != null) q.offer(node.left);
                if(node.right != null) q.offer(node.right);
            }
            res.add(new ArrayList(temp));
        }
        return res;
    }
}

2.N叉树

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> res = new ArrayList<>();
        if(root == null) return res;
        Queue<Node> q = new LinkedList<>();
        q.offer(root);
        while(!q.isEmpty()){
            int size = q.size();
            List<Integer> temp = new ArrayList<>();
            while(size -- > 0){
                Node node = q.poll();
                temp.add(node.val);
                for(Node x : node.children) q.offer(x);
            }
            res.add(new ArrayList(temp));
        }
        return res;
    }
}