Authur Whywait 做一块努力吸收知识的海绵
想看博主的所有leetcode卡片学习笔记？传送门点这儿

《N叉树》卡片将把我们关于二叉树的认知衍生到N叉树 (N - ary Tree) 。

N叉树的遍历

• 遍历
• N叉树的前序遍历🚩
• 递归法

• 递归法

• 分析
• BFS算法

遍历

对应于二叉树的四种遍历方式：前序遍历，中序遍历，后序遍历以及层序遍历（详情请点击传送门），N叉树也有。

不过对于中序遍历来说，只有在二叉树中有明确定义。而且N叉树的中序遍历无标准定义，实践中也不常用到，所以我们跳过N叉树的中序遍历部分。

具体遍历方式

1. 前序遍历：在N叉树中，先访问根节点，然后逐个遍历以其子节点为根的子树。
2. 后序遍历：在N叉树中，先逐个遍历以根节点的子节点为根的子树，最后访问根节点。
3. 层序遍历：N叉树的层序遍历与二叉树的一致。在树中进行广度优先搜索时，我们按照层序的顺序进行遍历。

接下来是相关编程练习~

N叉树的前序遍历🚩

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

递归法

# define SIZE 100000

void preorderNtree(struct Node* root, int* nums, int* returnSize){
if(!root) return;
nums[(*returnSize)++] = root->val;
for(int i=0; i<root->numChildren; i++) preorderNtree(root->children[i], nums, returnSize);
}

int* preorder(struct Node* root, int* returnSize) {
* returnSize = 0;
if(!root) return NULL;
int* nums = (int *)malloc(sizeof(int) * SIZE);
preorderNtree(root, nums, returnSize);
return nums;
}

类似二叉树前序遍历的递归，套用之前程序模板即可。

N叉树的后序遍历🚩

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

递归法

# define SIZE 100000

void postorderNtree(struct Node* root, int* nums, int* returnSize){
if(!root) return;
for(int i=0; i<root->numChildren; i++) postorderNtree(root->children[i], nums, returnSize);
nums[(*returnSize)++] = root->val;
}

int* postorder(struct Node* root, int* returnSize) {
* returnSize = 0;
if(!root) return NULL;
int* nums = (int *)malloc(sizeof(int) * SIZE);
postorderNtree(root, nums, returnSize);
return nums;
}

N叉树的层次遍历🚩

给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。

分析

只需对二叉树的层次遍历（[详情请点击传送门]的代码略作修改即可(https://blog.csdn.net/AuthurWhywat/article/details/105253887)）

BFS算法

/*
* @lc app=leetcode.cn id=429 lang=c
*
* [429] N叉树的层序遍历
*/

/**
* Definition for a Node.
* struct Node {
*     int val;
*     int numChildren;
*     struct Node** children;
* };
*/

/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
// typedef struct Node{
//     elementtype elementname;
// } name, * pointer;

// struct Node {
//     int val;
//     int numChildren;
//     struct Node** children;
// };
// # include<stdlib.h>

# define DEEP 100000
# define NODE 500000

int** levelOrder(struct Node* root, int* returnSize, int** returnColumnSizes) {
* returnSize = 0;
* returnColumnSizes = (int *)malloc(sizeof(int) * NODE);
* returnColumnSizes = 0;
if(!root) return NULL;
int **array = (int **)malloc(sizeof(int*) * DEEP);

struct Node* queue = (struct Node *)malloc(sizeof(struct Node) * NODE);
int front=0, tail=0;
* returnColumnSizes = (int *)malloc(sizeof(int) * NODE);

array[* returnSize] = (int *)malloc(sizeof(int));
array[* returnSize][0] = root->val;
(* returnColumnSizes)[* returnSize] = 1;
queue[tail++] = *root;

while(front<tail){
(* returnSize)++;
int counter=0;
int size=tail-front;
array[* returnSize] = (int *)malloc(sizeof(int) * NODE);
for(int i=0; i<size; i++){
if(!queue[front].numChildren){
front++;
continue;
}
for(int j=0; j<queue[front].numChildren; j++){
queue[tail++] = *(queue[front].children[j]);
array[* returnSize][counter++] = (*(queue[front].children[j])).val;
}
front++;
}
(* returnColumnSizes)[* returnSize] = counter;
}
return array;
}

都看到这里了，确定不点个赞再走？

• 点赞
• 收藏
• 分享
• 文章举报