[429].N 叉树的层序遍历

 

---

题目

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

树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）
 

---

函数原型

C 的函数原型：

/**
 * 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().
 */
int** levelOrder(struct Node* root, int* returnSize, int** returnColumnSizes) {
    
}

 

---

算法设计：队列

思路：逐次入队

#define MAXSIZE 10000
int** levelOrder(struct Node* root, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    if(root == NULL) {
        *returnColumnSizes = NULL;
        return NULL;
    }
    int** result = (int**)malloc(sizeof(int*) * MAXSIZE);
    *returnColumnSizes = (int*)malloc(sizeof(int) * MAXSIZE);
    struct Node* queue[MAXSIZE];
    int front = -1, rear = -1;
    queue[++rear] = root;   //根节点入队
    
    while(front != rear)
    {   
        int num = (rear - front)% MAXSIZE;
        (*returnColumnSizes)[*returnSize] = num;
        result[*returnSize] = (int*)malloc(sizeof(int) * num);
        for(int i = 0; i < num; i++)    //需要出队的结点个数
        {
            struct Node* p = queue[++front];
            result[*returnSize][i] = p -> val;
            for(int j = 0; j < p -> numChildren; j++)
            {   
                rear = (rear + 1) % MAXSIZE;
                queue[rear] = p -> children[j];
            }
        }
        (*returnSize)++;
    }
    return result;
}

• 时间复杂度：$\Theta (N)$
• 空间复杂度：$\Theta (N)$
   

---

算法设计：递归

思路：

class Solution {
public:
    vector<vector<int>> result;

    void dfs(Node* root, int dep){
        if(!root) return;
        if(dep == result.size()) result.emplace_back();
        result[dep].push_back(root->val);
        auto children = root->children;
        for(auto ele:children){
            dfs(ele, dep+1);
        }
    }
    vector<vector<int>> levelOrder(Node* root) {
        dfs(root, 0);
        return result;
    }
};

• 时间复杂度：$\Theta (N)$
• 空间复杂度：$\Theta (N)$