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)