剑指leetcode—N叉树的前序遍历

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

例如，给定一个 3叉树 :

树的遍历有着四种遍历方式

• 先序遍历
• 后序遍历
• 中序遍历
• 层次遍历

这里的要求是使用先序遍历，同时要求使用迭代法，递归法的思想很简单

递归法

给出递归法的算法思想

void preorder(node * b)
{
	if(b!=null)
	{
	printf("%d",b->data);
	preorder(b->lchild);
	preorder(b->rchile);
	}
}




 

返回其前序遍历: [1,3,5,6,2,4]。

这里的树是通过链表实现的，但是题目中，每一个结点都有对应的子节点的列表，所以简化了题目。

/*
// 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) {
       }
       }

解答如下

class Solution {
List <Integer> output=new ArrayList<Integer>();
   public List<Integer> preorder(Node root) {
   	if(root==null)
   	return output;
   	else
   		{
   	output.add(root.val);
   	for(int i=0;i<root.children.size();i++)
   		{
   	preorder(root.childred.get(i);
   		}
   		return output;
   	}

迭代法

使用一个栈来帮助我们得到前序遍历，需要保证栈顶的节点就是我们当前遍历到的节点。我们首先把根节点入栈，因为根节点是前序遍历中的第一个节点。随后每次我们从栈顶取出一个节点 u，它是我们当前遍历到的节点，并把 u 的所有子节点逆序推入栈中。例如 u 的子节点从左到右为 v1, v2, v3，那么推入栈的顺序应当为 v3, v2, v1，这样就保证了下一个遍历到的节点（即 u 的第一个子节点 v1）出现在栈顶的位置。

class Solution {
    public List<Integer> preorder(Node root) {
        LinkedList<Node> stack=new LinkedList<>();
        LinkedList<Integer> output=new LinkedList<>();
        if(root==null)
        return output;
    stack.add(root);
    while(!stack.isEmpty())
    {
        Node node=stack.pollLast();
        output.add(node.val);
        Collections.reverse(node.children);
        for(Node item:node.children){
            stack.add(item);
        }
    }
    return output;
    }
}

递归法，C语言实现

/**
 * Definition for a Node.
 * struct Node {
 *     int val;
 *     int numChildren;
 *     struct Node** children;
 * };
 */
/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 #define MAXSIZE 10000
 void pretraversa(struct Node * root,int * nums,int * i)
 {
     if(!root)
     return ;
     nums[(*i)]=root->val;
     (*i)++;
     for(int k=0;k<root->numChildren;k++)
     {
         pretraversa(root->children[k],nums,i);
     }
 }
int* preorder(struct Node* root, int* returnSize) {
    *returnSize=0;
    if(!root) return NULL;
    int i=0;
    int *nums=(int*)malloc(sizeof(int)*MAXSIZE);
    pretraversa(root,nums,&i);
    *returnSize=i;
    return nums;    
}