精华内容
下载资源
问答
  • 层次遍历

    2020-10-21 20:38:41
    编一个程序,读入用户输入的一串先序遍历字符串,根据输入建立一棵二叉树, 并输出该二叉树的层次遍历序列。层次遍历是指逐层访问,每一层又按从左到右的次序访问结点。 输入 输入包括1行字符串,长度不超过100。 ...

    题目描述
    编一个程序,读入用户输入的一串先序遍历字符串,根据输入建立一棵二叉树, 并输出该二叉树的层次遍历序列。层次遍历是指逐层访问,每一层又按从左到右的次序访问结点。
    输入
    输入包括1行字符串,长度不超过100。
    输出
    输出二叉树的层次遍历序列。每个结点先输出一个空格,然后再跟着输出结点的数据。
    样例输入 Copy
    12##3##
    样例输出 Copy
    1 2 3

    #include <iostream>
    #include <cstdio>
    #include <malloc.h>
    using namespace std;
    #define MAXSIZE 100
    
    typedef struct BiTnode
    {
        char data;
        struct BiTnode *lchild,*rchild;
    }BiTNode,*BiTree;
    
    typedef struct SQueue
    {
        BiTree data[MAXSIZE];
        int front,rear;
    }SQueue,*Queue;
    
    BiTree creatTree(BiTree T)
    {
        char ch;
        T=(BiTree)malloc(sizeof(BiTNode));
        scanf("%c",&ch);
        if(ch=='#') return 0;
        T->data=ch;
        T->lchild=creatTree(T->lchild);
        T->rchild=creatTree(T->rchild);
        return T;
    }
    
    void InitQueue(Queue Q)
    {
        Q -> front = Q -> rear = 0;
    }
    
    int IsEmptyQueue(Queue Q)
    {
        return Q -> rear == Q -> front?1:0;
    }
    
    void EnQueue(BiTree T,Queue Q)
    {
        if((Q -> rear+1) % MAXSIZE == Q -> front)
        {
            printf("Queue is fulled!\n");
            return  ;
        }
        Q->rear=(Q->rear+1)%MAXSIZE;
        Q->data[Q->rear]=T;
    }
    
    BiTree Gethead(Queue Q)
    {
        if(IsEmptyQueue(Q)) return 0;
        BiTree T;
        T=Q ->data[(Q ->front+1) % MAXSIZE];
        Q ->front=(Q ->front+1) % MAXSIZE;
        return T;
    }
    
    void LevelOrder(BiTree T)//层次遍历 
    {
        SQueue Q ;
        BiTree S ;
        if(!T) return ;
        InitQueue(&Q);
        EnQueue(T,&Q);
        while(!IsEmptyQueue(&Q))
        {
            S=Gethead(&Q);
            printf(" %c",S->data);
            if(S->lchild!=NULL) EnQueue(S->lchild,&Q);
            if(S->rchild!=NULL) EnQueue(S->rchild,&Q);
        }
    }
    
    int main()
    {
        BiTree tree;
        tree=creatTree(tree);
        LevelOrder(tree);
        return 0;
    }
    
    展开全文
  • 给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历) 给定一个...

    题目描述

    1. 给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。
    2. 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)
    3. 给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。

    例如:
    给定二叉树 [3,9,20,null,null,15,7],

        3
       / \
      9  20
        /  \
       15   7
    

    返回其层次遍历结果:

    [
      [3],
      [9,20],
      [15,7]
    ]
    

    返回其自底向上的层次遍历为:

    [
      [15,7],
      [9,20],
      [3]
    ]
    

    返回锯齿形层次遍历如下:

    [
      [3],
      [20,9],
      [15,7]
    ]
    

    题目解析

    该问题需要用到队列,三个问题的区别在于最终的数据存储不同

    层次遍历
    • 建立一个queue
    • 先把根节点放进去,这时候找根节点的左右两个子节点
    • 去掉根节点,此时queue里的元素就是下一层的所有节点
    • 用for循环遍历,将结果存到一个一维向量里
    • 遍历完之后再把这个一维向量存到二维向量里
    • 以此类推,可以完成层序遍历
    自底向上的层次遍历
    • 建立一个queue
    • 先把根节点放进去,这时候找根节点的左右两个子节点
    • 去掉根节点,此时queue里的元素就是下一层的所有节点
    • 用for循环遍历,将结果存到一个一维向量里
    • 遍历完之后再把这个一维向量插入到二维向量里
    • 以此类推,可以完成层序遍历
    锯齿形层次遍历
    • 建立一个queue
    • 先把根节点放进去,这时候找根节点的左右两个子节点
    • 去掉根节点,此时queue里的元素就是下一层的所有节点
    • 用for循环遍历,将结果存到一个一维向量里
    • 遍历完之后再把这个一维向量存到二维向量里
    • 如果该层为偶数层,则reverse翻转一下
    • 以此类推,可以完成层序遍历

    层次遍历代码实现

    /// BFS
    /// Time Complexity: O(n), where n is the number of nodes in the tree
    /// Space Complexity: O(n)
    class Solution {
    public:
        vector<vector<int>> levelOrder(TreeNode* root) {
    
            vector<vector<int>> res;
            if(root == NULL)
                return res;
    
            queue<pair<TreeNode*,int>> q;
            q.push(make_pair(root, 0));
    
            while(!q.empty()){
    
                TreeNode* node = q.front().first;
                int level = q.front().second;
                q.pop();
    
                if(level == res.size())
                    res.push_back(vector<int>());
                assert( level < res.size() );
    
                res[level].push_back(node->val);
                if(node->left)
                    q.push(make_pair(node->left, level + 1 ));
                if(node->right)
                    q.push(make_pair(node->right, level + 1 ));
            }
    
            return res;
        }
    };
    
    

    自底向上的层次遍历代码实现

    锯齿形层次遍历代码实现

    展开全文
  • 二叉树层次遍历算法——C/C++

    万次阅读 多人点赞 2019-06-16 00:32:47
    在进行层次遍历的时候,设置一个队列结构,遍历从二叉树的根节点开始,首先将根节点指针入队列,然后从队头取出一个元素,每取一个元素,执行下面两个操作: 访问该元素所指向的节点 若该元素所指节点的左右孩子...

    二叉树层次遍历

    层次遍历基础需要了解二叉树、队列。
    二叉树基本运算:https://blog.csdn.net/weixin_42109012/article/details/92000919
    顺序队基本运算:https://blog.csdn.net/weixin_42109012/article/details/92104948

    1. 算法思想

    用一个队列保存被访问的当前节点的左右孩子以实现层次遍历。
    在进行层次遍历的时候,设置一个队列结构,遍历从二叉树的根节点开始,首先将根节点指针入队列,然后从队头取出一个元素,每取一个元素,执行下面两个操作:

    1. 访问该元素所指向的节点
    2. 若该元素所指节点的左右孩子节点非空,则将该元素所指节点的左孩子指针和右孩子指针顺序入队。此过程不断进行,当队列为空时,二叉树的层次遍历结束。

    2. 原理解释

    2.1. 二叉树图

    一个二叉树,层次遍历就是每一行每一行的取出数据。
    这个图的结果就是 ABCDEFGH
    在这里插入图片描述

    2.2. 层次遍历过程图

    就是先父节点进入队列,然后循环,出队时带入下一组子节点进队,没有就没有进入队列的,当队列为空时结束循环。
    在这里插入图片描述

    3. 代码实现

    3.1 实现步骤

    1、首先将二叉树的根节点进入队列中,判断队列不为NULL。
    2、打印输出该节点存储的元素。
    3、判断节点如果有孩子(左孩子、右孩子),就将孩子进入队列中。
    4、循环以上操作,直到 BT->lchild == NULL、BT->rchild=NULL。

    3.2 全部代码

    #define _CRT_SECURE_NO_WARNINGS // VS忽略警告,其它应该不需要
    
    #include <malloc.h>
    #include <stdio.h>
    #include <string.h>
    
    #define MAX_SIZE 1024
    #define STR_SIZE 1024
    
    typedef struct Node {    // 定义二叉链
        char         data;   // 数据元素
        struct Node* lchild; // 指向左孩子节点
        struct Node* rchild; // 指向右孩子节点
    } BTNode;                // struct Node 的别名
    
    typedef struct Quene {      // 定义顺序队
        int     front;          // 队头指针
        int     rear;           // 队尾指针
        BTNode* data[MAX_SIZE]; // 存放队中元素
    } SqQueue;                  // struct Queue 的别名
    
    /**
     * 队列函数
     */
    void initQueue(SqQueue*& q);            // 初始化对立
    bool emptyQueue(SqQueue*& q);           // 判断队列空
    bool enQueue(SqQueue*& q, BTNode*& BT); // 入队
    bool deQueue(SqQueue*& q, BTNode*& BT); // 出队
    
    /**
     * 二叉树函数
     */
    // void createBTNode2(BTNode** BT);                  // 创建二叉树
    int  createBTNode(BTNode*& BT, char* str, int n); // 创建二叉树
    void preOrder(BTNode*& BT);                       // 前序遍历
    void inOrder(BTNode*& BT);                        // 中序遍历
    void postOrder(BTNode*& BT);                      // 后序遍历
    void levelOrder(BTNode*& BT);                     // 层次遍历
    
    /**
     * 画树函数
     */
    void draw_level(BTNode* root, bool left, char* str); // 画分支
    void draw(BTNode* root);                             // 画根节点
    
    /***************************************************************************
     * @date    2019/12/08
     * @brief   层次遍历二叉树
     * @param   BT  二叉树根节点
     ***************************************************************************/
    void levelOrder(BTNode*& BT) {
        SqQueue* q;   // 定义队列
        initQueue(q); // 初始化队列
        if (BT != NULL) {
            enQueue(q, BT); // 根节点指针进队列
        }
        // 一层一层的把节点存入队列,当没有孩子节点时就不再循环
        while (emptyQueue(q) != true) { // 队不为空循环
            deQueue(q, BT);             // 出队时的节点
            printf("%c", BT->data);     // 输出节点存储的值
            if (BT->lchild != NULL) {   // 有左孩子时将该节点进队列
                enQueue(q, BT->lchild);
            }
            if (BT->rchild != NULL) { // 有右孩子时将该节点进队列
                enQueue(q, BT->rchild);
            }
        }
    }
    
    int main() {
        // 例子:ABDH###E##CF##G##
        BTNode* BT;
        printf("请输入字符串:");
        char* str = (char*)malloc(sizeof(char) * STR_SIZE);
        scanf("%s", str);
        if (strlen(str) == createBTNode(BT, str, 0)) {
            printf("二叉树建立成功\n");
        }
        // printf("请输入字符串:");
        // createBTNode2(&BT);
        draw(BT);
    
        printf("\n先序遍历结果:");
        preOrder(BT);
    
        printf("\n中序遍历结果:");
        inOrder(BT);
    
        printf("\n后序遍历结果:");
        postOrder(BT);
    
        printf("\n层序遍历结果:");
        levelOrder(BT);
    
        return 0;
    }
    
    // 初始化队列
    void initQueue(SqQueue*& q) {
        q        = (SqQueue*)malloc(sizeof(SqQueue)); // 分配一个空间
        q->front = q->rear = -1;                      // 置 -1
    }
    
    // 判断队列是否为空
    bool emptyQueue(SqQueue*& q) {
        // 首指针和尾指针相等,说明为空。空-返回真,不空-返回假
        if (q->front == q->rear) {
            return true;
        } else {
            return false;
        }
    }
    
    // 进队列
    bool enQueue(SqQueue*& q, BTNode*& BT) {
        // 判断队列是否满了。满(插入失败)-返回假,不满(插入成功)-返回真
        if (q->rear == MAX_SIZE - 1) {
            return false;
        }
        q->rear++;             // 头指针加 1
        q->data[q->rear] = BT; // 传值
        return true;
    }
    
    // 出队列
    bool deQueue(SqQueue*& q, BTNode*& BT) {
        // 判断是否空了。空(取出失败)-返回真,不空(取出成功)-返回假
        if (q->front == q->rear) {
            return false;
        }
        q->front++;             // 尾指针加 1
        BT = q->data[q->front]; // 取值
        return true;
    }
    
    // 创建二叉树
    int createBTNode(BTNode*& BT, char* str, int n) {
        char ch = str[n];    // 把第 n 个字符赋给ch,方便后面判断
        n       = n + 1;     // 字符下标后移
        if (ch != '\0') {    // 如果 ch 不等于结束符就继续创建,否则就结束
            if (ch == '#') { // 以 # 号代表 NULL,下面没有了
                BT = NULL;
            } else {
                BT       = new BTNode;                       // 新建一个二叉链
                BT->data = ch;                               // 把字符存入二叉链
                n        = createBTNode(BT->lchild, str, n); // 左递归创建
                n        = createBTNode(BT->rchild, str, n); // 右递归创建
            }
        }
        // 返回 n,记录字符串使用到哪里了
        return n;
    }
    // 二级指针创建
    // void createBTNode2(BTNode** BT) {
    //     char ch;
    //     ch = getchar();
    //     if (ch == '#') {
    //         *BT = NULL;
    //     } else {
    //         if (!(*BT = (BTNode*)malloc(sizeof(BTNode)))) {
    //             printf("内存分配失败!");
    //             return;
    //         } else {
    //             (*BT)->data = ch;
    //             createBTNode2(&((*BT)->lchild)); // 分配成功则接着建立左子树和右子树
    //             createBTNode2(&((*BT)->rchild));
    //         }
    //     }
    // }
    
    // 先序遍历
    void preOrder(BTNode*& BT) {
        if (BT != NULL) {           // 判断不为空
            printf("%c", BT->data); // 访问根节点
            preOrder(BT->lchild);   // 递归,先序遍历左子树
            preOrder(BT->rchild);   // 递归,先序遍历右子树
        }
    }
    
    // 中序遍历
    void inOrder(BTNode*& BT) {
        if (BT != NULL) {
            inOrder(BT->lchild);
            printf("%c", BT->data);
            inOrder(BT->rchild);
        }
    }
    
    // 后序遍历
    void postOrder(BTNode*& BT) {
        if (BT != NULL) {
            postOrder(BT->lchild);
            postOrder(BT->rchild);
            printf("%c", BT->data);
        }
    }
    
    /*****************************************************************************
    * @date   2020/4/19
    * @brief  水平画树
    * @param  root	二叉树节点
    * @param  left	判断左右
    * @param  str 	可变字符串
    *****************************************************************************/
    void draw_level(BTNode* root, bool left, char* str) {
        if (root->rchild) {
            draw_level(root->rchild, false, strcat(str, (left ? "|     " : "      ")));
        }
    
        printf("%s", str);
        printf("%c", (left ? '\\' : '/'));
        printf("-----");
        printf("%c\n", root->data);
    
        if (root->lchild) {
            draw_level(root->lchild, true, strcat(str, (left ? "      " : "|     ")));
        }
        //  "      " : "|     " 长度为 6
        str[strlen(str) - 6] = '\0';
    }
    
    /*****************************************************************************
    * @date   2020/4/19
    * @brief  根节点画树
    * @param  root	二叉树根节点
    *****************************************************************************/
    void draw(BTNode* root) {
        char str[STR_SIZE];
        memset(str, '\0', STR_SIZE);
    
        if (root->rchild) {
            draw_level(root->rchild, false, str);
        }
        printf("%c\n", root->data);
        if (root->lchild) {
            draw_level(root->lchild, true, str);
        }
    }
    
    

    4. 结果展示

    创建二叉树是以 “#” 为结束符NULL。
    例子就是最上面的图:ABDH###E##CF##G##
    结果应该为:ABCDEFGH
    在这里插入图片描述

    展开全文
  • 二叉树的层次遍历深度优先&广度优先给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。例如: 给定二叉树: [3,9,20,null,null,15,7],3 / 9 20 / 15 7返回其层次遍历结果:...

    1a2ec8eae5160b465d8cafe3f4e16e9d.png

    二叉树的层次遍历

    深度优先&广度优先

    给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。

    例如: 给定二叉树: [3,9,20,null,null,15,7],

    3
       / 
      9  20
        /  
       15   7

    返回其层次遍历结果:

    [
      [3],
      [9,20],
      [15,7]
    ]

    Mine

    class Solution {
        public List<List<Integer>> levelOrder(TreeNode root) {
            List<List<Integer>> res = new ArrayList<>();
            helper(res, root, 0);
            return res;
        }
    
        private void helper(List<List<Integer>> res, TreeNode root, int depth) {
            if (root == null) return;
            if (res.size() == depth) res.add(new LinkedList<>());
            res.get(depth).add(root.val);
            helper(res, root.left, depth + 1);
            helper(res, root.right, depth + 1);
        }
    }
    看了一下递归最快。

    Standard Answer

    class Solution {
      public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> levels = new ArrayList<List<Integer>>();
        if (root == null) return levels;
    
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        int level = 0;
        while ( !queue.isEmpty() ) {
          // start the current level
          levels.add(new ArrayList<Integer>());
    
          // number of elements in the current level
          int level_length = queue.size();
          for(int i = 0; i < level_length; ++i) {
            TreeNode node = queue.remove();
    
            // fulfill the current level
            levels.get(level).add(node.val);
    
            // add child nodes of the current level
            // in the queue for the next level
            if (node.left != null) queue.add(node.left);
            if (node.right != null) queue.add(node.right);
          }
          // go to next level
          level++;
        }
        return levels;
      }
    }
    
    作者LeetCode
    链接https://leetcode-cn.com/problems/binary-tree-level-order-traversal/solution/er-cha-shu-de-ceng-ci-bian-li-by-leetcode/
    来源力扣LeetCode
    著作权归作者所有商业转载请联系作者获得授权非商业转载请注明出处
    官方解答的那个递归我觉得写的不太好,这个是递归的解法。

    Java LinkedList.get() 获取元素

    1. get(int index):返回此列表中指定位置处的元素。
    2. getFirst():返回此列表的第一个元素。
    3. getLast():返回此列表的最后一个元素。
    4. indexOf(Object o):返回此列表中首次出现的指定元素的索引,如果此列表中不包含该元素,则返回 -1。
    5. lastIndexOf(Object o):返回此列表中最后出现的指定元素的索引,如果此列表中不包含该元素,则返回 -1

    应该会暂时停更几天,消化一下所学。

    展开全文
  • DP问题,欢迎关注 动态规划一篇就够了 全网最详细, 逐步理解, 万字总结 - Johngo的文章 - 知乎 https://zhuanlan.zhihu.com/p/130743652二叉树层次遍历二叉树的遍历方式主要由先序遍历、中序遍历和后续遍历,还后...
  • leetcode 第102题 二叉树的层次遍历, 第103题二叉树的锯齿形层次遍历, 第107题 二叉树的层次遍历 II 问题分析 这三道题都考察的都是二叉树的广度优先遍历,二叉树的广度优先遍历非常明显,就是按照顺序输出每一层...
  • 实现二叉树的层次遍历实现二叉树的层次遍历实现二叉树的层次遍历实现二叉树的层次遍历
  • 前两天说过二叉树的前序遍历、中序遍历、后续遍历,把剩下的也都说了吧,二叉树遍历系列四,层次遍历。题目链接:二叉树的层次遍历 - 力扣(LeetCode)​leetcode-cn.com题目描述:给定一个二叉树,返回其按层次遍历...
  • 最近好像掌握了些调色的技巧色彩好像比以前处理的图片要明亮一些直接上图107-二叉树的层次遍历给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)例如...
  • 这次来写一下 LeetCode 的第 102 题,二叉树的层次遍历。题目描述 题目直接从 LeetCode 上截图过来,题目如下: 上面的题就是 二叉树的层次遍历 题目的截图,同时 LeetCode 会根据选择的语言给出一个类的定义或者...
  • 也很好吃102-二叉树的层次遍历给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。例如:给定二叉树: [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回其层次遍历...
  • 二叉树层次遍历按照二叉树中的层次从左到右依次遍历每层中的结点。具体的实现思路是:通过使用队列的数据结构,从树的根结点开始,依次将其左孩子和右孩子入队。而后每次队列中一个结点出队,都将其左孩子和右孩子...
  • 103. 二叉树的锯齿形层次遍历 思路:二叉树的层次遍历采用广度优先搜索策略,循环体内遍历树中一层结点,所以在进入循环体内需要对队列中结点个数进行计数。需要注意的是题意要求正序和逆序遍历层中结点交替进行,是...
  • 二叉树的层次遍历 力扣​leetcode-cn.com 给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)思路:按照 BFS(Breath-First-Search)广度优先搜素的方法,通过维护一个队列,依序将...
  • 5(107) 二叉树的层次遍历Ⅱ描述给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)示例给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7...
  • 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)例如:给定二叉树 [3,9,20,null,null,15,7],3 / 9 20 / 15 7返回其自底向上的层次遍历为:[ ...
  • 每日一算法-二叉树的层次遍历 II题目给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)例如:给定二叉树[3,9,20,null,null,15,7], 3 / \ 9 20 / \ ...
  • 给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。 例如: 给定二叉树 [3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回锯齿形层次...
  • LeetCode上第103 号问题:二叉树的锯齿形层次遍历题目描述 给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。例如:给定二叉树: [3,9,20,...
  • 这次来写一下 LeetCode 的第 102 题,二叉树的层次遍历。题目描述题目直接从 LeetCode 上截图过来,题目如下:102.二叉树的层次遍历题目上面的题就是 二叉树的层次遍历 题目的截图,同时 LeetCode 会根据选择的语言...
  • 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历) 例如: 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其自底向上的层次遍历...
  • 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历) 例如: 给定二叉树 [3,9,20,null,null,15,7], 3 /\ 9 20 / \ 15 7 返回其自底向上的层次遍历为: ...
  • 二叉树的层次遍历II题目题解给定一个二叉树,返回其节点值自底向上的层次遍历。(即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历)例如:给定二叉树 [3,9,20,null,null,15,7],3/\920/\157返回其自底向上的...
  • 给定一个二叉树,返回其节点值的锯齿形层次遍历。(即先从左往右,再从右往左进行下一层遍历,以此类推,层与层之间交替进行)。例如:给定二叉树 [3,9,20,null,null,15,7],3 / 9 20 / 15 7返回锯齿形层次遍历...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,758
精华内容 5,903
关键字:

层次遍历