方法一：使用宽度遍历（BFS）非递归使用队列
    遇到问题：1、queue队列使用push,pop进行压入与弹出，同时注意压入弹出的数据类型，可能是指针类型注意加*，如下面代码段压入队列的为指针类型，以及之后需要调用赋值也需要注意指针类型

    1. void level(Node* root, vector<vector<int>>* result){
    2.     queue<Node*>orderqueue;
    3.     orderqueue.push(root);
    4.     Node* head;
    5.     head=orderqueue.front();
    6. }

    2、指针所对应的模板函数调用应该使用->
    3、使用auto进行遍历for(auto&i:head->children)

    1. /*
    2. // Definition for a Node.
    3. class Node {
    4. public:
    5.     int val;
    6.     vector<Node*> children;
    8.     Node() {}
    10.     Node(int _val) {
    11.         val = _val;
    12.     }
    14.     Node(int _val, vector<Node*> _children) {
    15.         val = _val;
    16.         children = _children;
    17.     }
    18. };
    19. */
    21. class Solution {
    22. public:
    23.     vector<vector<int>> levelOrder(Node* root) {
    24.         vector<vector<int>>result;
    25.         level(root,&result);
    26.         return result;
    27.     }
    28. public:
    29.     void level(Node* root, vector<vector<int>>* result)
    30.     {
    31.         if(root==NULL){
    32.             return;
    33.         }
    34.         queue<Node*>orderqueue;
    35.         orderqueue.push(root);
    36.         Node* head;
    37.         while(!orderqueue.empty())
    38.         {
    39.             int s=orderqueue.size();
    40.             vector<int>result1;
    41.             while(s--){
    42.                 head=orderqueue.front();
    43.                 orderqueue.pop();
    44.                 result1.push_back(head->val);
    45.                 for(auto&i:head->children){
    46.                 orderqueue.push(i);
    47.                 }
    48.             }
    49.             result->push_back(result1);
    50.             result1.clear();        
    51.         }
    52.     }
    53. };

    方法二：使用深度遍历（DFS）递归方法
    遇到问题：1、对应vertor>数据类型在存放时需要申请空元素占位,注意学习该元素的压入数据方式

    1. vector<vector<int>>result;
    2. result.emplace_back();

    2、调用函数时使用引用方式可能减少很多麻烦

    1. class Solution {
    2. public:
    3.     vector<vector<int>> levelOrder(Node* root) {
    5.         perorder(root,0,result);
    6.         return result;
    7.     }
    8.     void perorder(Node* root, int d, vector<vector<int>>& result){
    9.          if(root==NULL){
    10.             return;
    11.         }
    12.         if(result.size()==d){
    13.             result.emplace_back();
    14.         }
    15.         result[d].push_back(root->val);
    16.         for(auto& i:root->children){
    17.             perorder(i,d+1,result);
    18.         }
    20.     }
    21.     vector<vector<int>>result;
    22. };