Authur Whywait 做一块努力吸收知识的海绵
想看博主的所有leetcode卡片学习笔记?传送门点这儿
《N叉树》卡片将把我们关于二叉树的认知衍生到N叉树 (N - ary Tree) 。
遍历
对应于二叉树的四种遍历方式:前序遍历,中序遍历,后序遍历以及层序遍历(详情请点击传送门),N叉树也有。
不过对于中序遍历来说,只有在二叉树中有明确定义。而且N叉树的中序遍历无标准定义,实践中也不常用到,所以我们跳过N叉树的中序遍历部分。
具体遍历方式
- 前序遍历:在N叉树中,先访问根节点,然后逐个遍历以其子节点为根的子树。
- 后序遍历:在N叉树中,先逐个遍历以根节点的子节点为根的子树,最后访问根节点。
- 层序遍历: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;
}
都看到这里了,确定不点个赞再走?