N叉树的前序遍历

题目描述：

589. N 叉树的前序遍历

给定一个 N 叉树，返回其节点值的 前序遍历 。

N 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

进阶：

递归法很简单，你可以使用迭代法完成此题吗?

给定一个 N 叉树，返回其节点值的 前序遍历 。

N 叉树 在输入中按层序遍历进行序列化表示，每组子节点由空值 null 分隔（请参见示例）。

进阶：

递归法很简单，你可以使用迭代法完成此题吗?

示例 1：

输入：root = [1,null,3,2,4,null,5,6]
输出：[1,3,5,6,2,4]

示例 2：

输入：root = [1,null,2,3,4,5,null,null,6,7,null,8,null,9,10,null,null,11,null,12,null,13,null,null,14]
输出：[1,2,3,6,7,11,14,4,8,12,5,9,13,10]

提示：

• N 叉树的高度小于或等于 1000
• 节点总数在范围 [0, 10^4] 内

力扣https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/

解题思路：

建立一个循环，每一次先将栈顶元素出栈，并加入List中，然后判断栈顶元素有没有子节点，有的话将子节点逆序加入到栈中，没有的话继续循环。

到了最后的节点一定是没有了子节点，那么stack栈没有了进栈、一直出栈一直出栈，最后栈一定会为空，此时结束循环。

画图：

1，根节点1进入栈：

2，栈顶元素1出栈，进入outList，判断节点1有没有子节点，有——{3,2,4}，于是将子节点们逆序之后，入栈：

 3，栈顶元素3出栈，进入outList，判断节点3有没有子节点，有——{5,6}，于是将子节点们逆序之后，入栈：

4，栈顶元素5出栈， 进入outList，判断节点5有没有子节点，没有——那就没啥毛事；

5， 栈顶元素6出栈， 进入outList，判断节点6有没有子节点，没有——那就没啥毛事；

6，节点2和节点4同上，没有子节点，则依次出栈并进入outList即可；

 

7，栈为空，结束循环；

示例代码：

package zyh.springcloud.chapter2.service.impl.datastructure.stack;

import java.lang.reflect.Array;
import java.util.*;

/**
 * @ClassName NAryTreePreorderTraversal
 * @Author zhangyonghui
 * @Description：N叉树的前序遍历
 * @Date 2021/10/8 17:10
 * @Version 1.0
 **/
public class NAryTreePreorderTraversal {

        private List<Integer> outList = new ArrayList<>();

        /**
         * 递归方法：
         * @param root
         * @return
         */
        public List<Integer> preorder1(Node root) {
                if (root == null) {
                        return outList;
                }
                outList.add(root.val);
                List<Node> childrenList = root.children;
                if (childrenList.size() != 0) {
                        for (Node node : childrenList) {
                                preorder1(node);
                        }
                }
                return outList;
        }


        /**
         * 迭代法：
         * 思路：
         *      建立一个循环：
         *              1，每一次先将栈顶元素出栈，并加入到List中；
         *              2，然后判断该栈顶元素有没有子节点，如果有的话，将子节点们逆序加入到栈中，没有的话继续循环；
         * @param root
         * @return
         */
        public List<Integer> preorder2(Node root) {
                //初始化一个返回集合：
                List<Integer> outList = new ArrayList<>();

                if (root == null) {
                        return outList;
                }
                //新建一个栈：
                Deque<Node> stack = new LinkedList<>();

                //先将根节点进栈，下边马上就出栈，进入List：
                stack.push(root);

                //建立循环：
                while (true) {
                        //4，到了最后的节点一定是没有了子节点，那么stack栈没有了进栈、一直出栈一直出栈，最后栈一定会为空，此时结束循环：
                        if (stack.isEmpty()) {
                                break;
                        }
                        //1，先将栈顶元素出栈，并加入到List中：
                        Node popNode = stack.pop();
                        outList.add(popNode.val);
                        //2，然后判断该栈顶元素有没有子节点：
                        List<Node> childrens = popNode.children;
                        //3，如果有子节点，则将子节点们逆序加入到栈中：
                        if (childrens.size() != 0) {
                                Collections.reverse(childrens);
                                for (Node children : childrens) {
                                        stack.push(children);
                                }
                        }
                }


                return outList;
        }
}