Leetcode 关于树的题：589. N-ary Tree Preorder Traversal 和 429. N-ary Tree Level Order Traversal

Leetcode 关于树的题，放在一起便于理解和复习

1. N-ary Tree Postorder Traversal 树的后续遍历
2. N-ary Tree Preorder Traversal 树的先序遍历
3. N-ary Tree Level Order Traversal 按层遍历树

590. N-ary Tree Postorder Traversal

Given an n-ary tree, return the postorder traversal of its nodes’ values.

For example, given a 3-ary tree:

Return its postorder traversal as: [5,6,3,2,4,1].

Note: Recursive solution is trivial, could you do it iteratively?

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

    public Node() {}

    public Node(int _val,List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    public List<Integer> postorder(Node root) {
        List<Integer> result = new LinkedList<Integer>();
        core(result, root);
        return result;        
    }

    public void core(List<Integer> list, Node root) {
        if(root != null) {                     
            for(Node node: root.children) {
               core(list, node);
            }                                
            list.add(root.val);
        }
    }
}

后续遍历一棵树，要求用递归的方式，首先遍历根节点，如果有孩子，则依次遍历孩子节点。遍历时，先把子节点加入到列表，然后把父节点加入到列表。

589. N-ary Tree Preorder Traversal

Given an n-ary tree, return the preorder traversal of its nodes’ values.

For example, given a 3-ary tree:

Return its preorder traversal as: [1,3,5,6,2,4].

Note: Recursive solution is trivial, could you do it iteratively?

先序遍历一棵树，要求用递归的方式，首先遍历根节点，如果有孩子，则依次遍历孩子节点。遍历时，先把父节点加入到列表，然后把子节点加入到列表。

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

    public Node() {}

    public Node(int _val,List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    public List<Integer> preorder(Node root) {
        List<Integer> list = new LinkedList<Integer>();
        core(list, root);
        return list;
    }

    public void core(List<Integer> list, Node root) {
        if(root != null) {
            list.add(root.val);
            for(Node child: root.children) {
                core(list, child);
            }                 
        }
    }
}

429. N-ary Tree Level Order Traversal

Given an n-ary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example, given a 3-ary tree:

We should return its level order traversal:

按层遍历一棵树，用广搜

[
[1],
[3,2,4],
[5,6]
]

Note:

The depth of the tree is at most 1000.
The total number of nodes is at most 5000.

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

    public Node() {}

    public Node(int _val,List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/
class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> result = new LinkedList<List<Integer>>();
        if(root == null) {
            return result;
        }
        List<Node> list = new LinkedList<Node>();
        list.add(root);
        while(list.size() > 0) {
            int lineNum = list.size();
            List<Integer> temp = new LinkedList<Integer>();
            for(int i = 0; i < lineNum; i++) {
                Node node = list.get(0);    
                temp.add(node.val);
                if(node.children != null) {
                    list.addAll(node.children);
                }
                list.remove(0);
            }
            result.add(temp);    
        }
        return result;
    }

}