leetcode【数据结构简介】《N叉树》卡片 - 遍历

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

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

遍历

对应于二叉树的四种遍历方式：前序遍历，中序遍历，后序遍历以及层序遍历（详情请点击传送门），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.youkuaiyun.com/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;
}

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