N叉树的前序/后序/层序遍历

589. N 叉树的前序遍历

递归

• 根节点加入list
• 递归遍历孩子节点

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

class Solution {
    List<Integer> list=new ArrayList<>();
    public List<Integer> preorder(Node root) {
        if(root==null){
            return list;
        }

        list.add(root.val);

        for(Node node:root.children){
            preorder(node);
        }

        return list;

    }
}

迭代

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

class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> list=new ArrayList<>();
        Deque<Node> stack=new LinkedList<>();
        if(root==null){
            return list;
        }

        stack.push(root);
        while(!stack.isEmpty()){
            Node node=stack.pop();
            list.add(node.val);
            //栈是先进后出：每一层节点要逆序加入出栈才是正序
            /*
            或者先逆个序然后正想遍历入栈
            Collections.reverse(node.children);
            for (Node item : node.children) {
                stack.add(item);
            }
            */
            for(int i=node.children.size()-1;i>=0;i--){
                stack.push(node.children.get(i));
            }    
        }
        return list;
    }
}

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

class Solution {
    List<Integer> list=new ArrayList<>();
    public List<Integer> postorder(Node root) {
        if(root==null){
            return list;
        }

        for(Node node:root.children){
            postorder(node);
        }
        list.add(root.val);

        return list;

    }
}

迭代

• 头插list
• 正序遍历孩子节点

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

class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> list=new ArrayList<>();
        Deque<Node> stack=new LinkedList<>();

        if(root==null){
            return list;
        }

        stack.push(root);
        while(!stack.isEmpty()){
            Node node=stack.pop();
            //头插list接口没有addFirst()方法
            list.add(0,node.val);
            //正序遍历就是即可：因为是头插就倒序就返回正序
            for(int i=0;i<node.children.size();i++){
                stack.push(node.children.get(i));
            }
           
        }

        return list;
    }
}

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

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> list=new ArrayList<>();
        
        Deque<Node> queue=new LinkedList<>();

        if(root!=null){
            queue.add(root);
        }

        while(!queue.isEmpty()){
            List<Integer> path=new ArrayList<>();
            
            int size=queue.size();

            for(int i=0;i<size;i++){
                Node node=queue.remove();

                path.add(node.val);

                queue.addAll(node.children);
            }
            list.add(path);
        }

        return list;
    }
}

时间复杂度O(n)
空间复杂度O(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;
    }
};
*/

class Solution {
    List<List<Integer>> list=new ArrayList<>();
    public List<List<Integer>> levelOrder(Node root) {
        if(root!=null){
            dfs(root,0);
        }
        return list;
    }

    public void dfs(Node root,int level){
        if(list.size()<=level){
            list.add(new ArrayList<>());
        }

        list.get(level).add(root.val);

        for(Node child:root.children){
            dfs(child,level+1);
        }
        
    }
}

时间复杂度O(n)
空间复杂度O(n)