精华内容
下载资源
问答
  • 二叉树层次遍历算法

    千次阅读 2020-08-27 01:23:39
    层次遍历 其实记住以上的输出顺序还是非常简单的。首先要明白,左节点一定先比右节点输出! 那么就很好理解了,那么那些所谓的前序、中序、后序而言是针对根节点的相对位置命名的。 例如前序遍历,则就是根节点是最...

    在二叉树中,我们常见的遍历方式 主要有四种。分别是:

    • 前序遍历(根节点->左节点->右节点)
    • 中序遍历(左节点->根节点->右节点)
    • 后序遍历(左节点->右节点->根节点)
    • 层次遍历

    其实记住以上的输出顺序还是非常简单的。首先要明白,左节点一定先比右节点输出
    那么就很好理解了,那么那些所谓的前序、中序、后序而言是针对根节点的相对位置命名的。
    例如前序遍历,则就是根节点是最前面输出的,所以我们不难得到,前序遍历的顺序为:根节点->左节点->右节点。其他同理。

    那么今天介绍下一种不同的方式—层次遍历。注意层次队列不能使用递归来完成,并且需要借助一个队列来帮我们完成整个过程的遍历!

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    #define  ElemType char
    #define maxSize 100
    typedef struct Tree{
    	ElemType data;
    	struct Tree * rchild;
    	struct Tree * lchild;
    }Tree,*Treep;
    
    /*
    	采用前序遍历的思想创建二叉树 
    */ 
    void createTree(Tree * &p){
    	char c;
    	scanf("%c",&c);
    	if(c == ' '){
    		return;
    	}
    	p = (Tree *)malloc(sizeof(Tree));
    	p->data = c;
    	p->lchild = NULL;
    	p->rchild = NULL;
    	createTree(p->lchild);
    	createTree(p->rchild);
    	
    }
    /*
    	该算法的主要思想是
    		1. 输出根节点的值
    		2. 把该节点的左孩子添加到队列
    		3. 把该节点的右孩子添加到队列
    		4. 从队列一一取出 重复上述步骤。
    		 
    		在遍历当前层次的时候,输出当前节点,并把下一层次
    		的节点按左右节点顺序存入队列。
    		队列的特点是:先进先出 那么这就很好的利用了队列的特点
    		达到了层次遍历的效果。 
    */ 
    void levelPrint(Tree * p){
    	//初始化一个非循环队列
    	Treep stack[maxSize];
    	int front,real;
    	front = real = 0;
    	Tree *curr ,*pre;
    	pre = p;
    	while(pre != NULL){
    		// 输出当前节点的值 
    		cout<<pre->data;
    		// 拿到当前节点的左孩子指针 
    		curr = pre->lchild;
    		//如果左孩子不为空 入队!
    		if(curr != NULL){
    			stack[real++] = curr;
    		}
    		// 如果右孩子不为空 入队! 
    		curr = pre->rchild;
    		if(curr != NULL){
    			stack[real++] = curr;
    			
    		}
    		// 如果队列不为空则从队列取出元素 
    		if( front != real) 
    			pre = stack[front++];
    		else //否则直接置空指针 
    			pre = NULL;
    		
    	}
    }
    
    int main(int argc, char** argv) {
    	Tree *root;
    	// 前序创建二叉树 
    	createTree(root);
    	// 层次遍历二叉树 
    	levelPrint(root);
    	return 0;
    }
    
    展开全文
  • Java 二叉树层次遍历

    千次阅读 2020-06-06 16:28:41
    Java 二叉树层次遍历

    Java 二叉树层次遍历

    简介: 遍历是对树的一种最基本的运算,所谓遍历二叉树,就是按一定的规则和顺序走遍二叉树的所有结点,使每一个结点都被访问一次,而且只被访问一次。

    设L、D、R分别表示遍历左子树、访问根结点和遍历右子树, 则对一棵二叉树的遍历有几种情况:DLR(称为先序遍历),LDR(称为中序遍历),LRD (称为后序遍历),层次遍历。

    **层次遍历:**按照层次访问,通常用队列来做。访问根,访问子女,再访问子女的子女(越往后的层次越低)(两个子女的级别相同)。

    如图二叉树的层次遍历结果为: 3,9,20,15,7
    在这里插入图片描述
    代码实现:

    public static void main(String[] args) {
        TreeNode root = new TreeNode(3);
        TreeNode n1 = new TreeNode(9);
        TreeNode n2 = new TreeNode(20);
        TreeNode n3 = new TreeNode(15);
        TreeNode n4 = new TreeNode(7);
        root.left = n1;
        root.right = n2;
        n2.left = n3;
        n2.right = n4;
    
        List<List<Integer>> rs = levelOrder(root);
        System.out.println(rs);
    }
    
    public static List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> list = new LinkedList<List<Integer>>();
        if (root == null)
            return list;
        ArrayDeque<TreeNode> deque = new ArrayDeque<>();
        deque.addLast(root);
    
        while (!deque.isEmpty()) {
            int num = deque.size();
            List<Integer> subList = new LinkedList<Integer>();
            for (int i = 0; i < num; i++) {
                TreeNode node = deque.removeFirst();
                if (node.left != null) deque.addLast(node.left);
                if (node.right != null) deque.addLast(node.right);
                subList.add(node.val);
            }
            list.add(subList);
        }
        return list;
    }
    

    在这里插入图片描述

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

    万次阅读 多人点赞 2019-06-16 00:32:47
    二叉树层序遍历 1、算法思想 用一个队列保存被访问的当前节点的左右孩子以实现层序遍历。 在进行层次遍历的时候,设置一个队列结构,遍历从二叉树的根节点...此过程不断进行,当队列为空时,二叉树层次遍历结束...

    二叉树层次遍历

    层次遍历基础需要了解二叉树、队列。
    二叉树基本运算: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 <stdbool.h>
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    
    #define MAX_SIZE 128
    #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* node);  // 入队
    bool deQueue(SqQueue* q, BTNode** node); // 出队
    
    /**
     * 二叉树函数
     */
    // 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* node, 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)) {      // 队不为空循环
            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) {
        if (!((*q) = (SqQueue*)malloc(sizeof(SqQueue)))) {
            printf("内存分配失败!");
            exit(-1);
        }
        (*q)->front = (*q)->rear = -1; // 置 -1
    }
    
    // 判断队列是否为空
    bool emptyQueue(SqQueue* q) {
        // 首指针和尾指针相等,说明为空。空-返回真,不空-返回假
        if (q->front == q->rear) {
            return true;
        }
        return false;
    }
    
    // 进队列
    bool enQueue(SqQueue* q, BTNode* node) {
        // 判断队列是否满了。满(插入失败)-返回假,不满(插入成功)-返回真
        if (q->rear == MAX_SIZE - 1) {
            return false;
        }
        q->rear++;               // 头指针加 1
        q->data[q->rear] = node; // 传值
        return true;
    }
    
    // 出队列
    bool deQueue(SqQueue* q, BTNode** node) {
        // 判断是否空了。空(取出失败)-返回假,不空(取出成功)-返回真
        if (q->front == q->rear) {
            return false;
        }
        q->front++;                // 尾指针加 1
        *node = q->data[q->front]; // 取值
        return true;
    }
    
    // 创建二叉树
    int createBTNode(BTNode** BT, char* str, int n) {
        char ch = str[n++];  // 把第 n 个字符赋给ch,方便后面判断,字符下标后移
        if (ch != '\0') {    // 如果 ch 不等于结束符就继续创建,否则就结束
            if (ch == '#') { // 以 # 号代表 NULL,下面没有了
                *BT = NULL;
            } else {
                if (!(*BT = (BTNode*)malloc(sizeof(BTNode)))) {
                    printf("内存分配失败!");
                    exit(-1);
                } else {
                    (*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  node	二叉树节点
    * @param  left	判断左右
    * @param  str 	可变字符串
    *****************************************************************************/
    void draw_level(BTNode* node, bool left, char* str) {
        if (node->rchild) {
            draw_level(node->rchild, false, strcat(str, (left ? "|     " : "      ")));
        }
    
        printf("%s", str);
        printf("%c", (left ? '\\' : '/'));
        printf("-----");
        printf("%c\n", node->data);
    
        if (node->lchild) {
            draw_level(node->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);
    
        /**
         * 1. 在 windows 下,下面是可执行的
         * 2. 在 Linux   下,执行会报 Segmentation fault
         *      需要使用中间变量
         */
        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
    在这里插入图片描述

    展开全文
  • 2、层次遍历二叉树。输入二叉树头节点的指针。先将头节点入队,将结点指针交给P,后出队。然后再将P左右孩子入队。循环至全部遍历。 注意递归创建过程: 因为先序创建二叉树是左右递归创建,所以一个结束符是结束了...

    /二叉树的竖向显示就是二叉树的按层显示。
    编写数据结构和算法来实现。要求:算法输入参数为一颗二叉树,无输出参数,显示过程在函数体内部直接执行
    /
    分析过程
    1、先序创建二叉树,输入一个值作为结点,申请空间存放数据,递归访问左右孩子结点。用#表示结点为空,同时跳出一侧的递归循环。
    2、层次遍历二叉树。输入二叉树头节点的指针。先将头节点入队,将结点指针交给P,后出队。然后再将P左右孩子入队。循环至全部遍历。

    注意递归创建过程:
    因为先序创建二叉树是左右递归创建,所以一个结束符是结束了一侧的递归调用,两个结束符号结束两侧的递归调用。可以理解将普通二叉树看作满二叉树,结束符是满二叉树当中的空位。

    #define MAX_SIZE  20            //层次遍历的队列大小
    #define elemtype char           //类型为char                        
    typedef struct BTNode
    {  elemtype  data ;
    struct BTNode  *Lchild , *Rchild;
    }BTNode,*Btree ;               //二叉树数据结构
    typedef struct  {
        Btree queue[MAX_SIZE];
        int front,rear;
    }Queue;                        //层次遍历队列
    void preoder_initBtree ( Btree &btree );    //先序遍历创建二叉树
    void visit(Btree &btree);                   //访问函数
    void leveorder(Btree &btree);               //层次遍历函数
    #include<stdio.h>
    #include<stdlib.h>
    void preoder_initBtree(Btree &btree){                //先序创建二叉树
        elemtype ch;
        scanf("%c", &ch);                                //输入一个值作为结点
        if(ch =='#')                                     //#号标识结点为空跳出递归
        {
            btree=NULL;
        }
        else
        {
            btree=(Btree)malloc(sizeof(BTNode));         //申请空间
            btree->data=ch;
            preoder_initBtree(btree->Lchild);            //左孩子递归
            preoder_initBtree(btree->Rchild);            //右孩子递归
        }
    }
    void visit(Btree &btree)
    {
        if(btree!=NULL)
        printf("%c\t", btree->data);                    //打印结点数据
    }
    void leveorder(Btree &T)
    {
    Queue q;                                           //层次变量的队列
    Btree p;                                            
    q.front=0;
    q.rear=0;                                          //队列初始化
    q.queue[q.rear]=T;                                 //头节点入队列
    q.rear++;                                          //队尾加1
    while(q.front!=q.rear){                             
        p=q.queue[q.front];                            
        visit(q.queue[q.front]);
        q.front++;                                     //结点出队队首减1
        if(p->Lchild){
            q.queue[q.rear]=p->Lchild;                 
            q.rear++;                                    //访问左孩子入队尾
            }
        if(p->Rchild){
            q.queue[q.rear]=p->Rchild;
            q.rear++;                                    //右孩子入队尾
            }
        }
    }
    int main()
    {
    Btree btree;
    printf("put in the Bitree: \n");
    preoder_initBtree(btree);
    //Print(btree);
    leveorder(btree);
    while(1);
    return 0;
    }
    
    展开全文
  • 1.二叉树层次遍历 2.二叉树结构图的打印 结语 1.二叉树层次遍历 主要用到队列操作,先入队根结点,再不断出队,判断出队结点是否有左右孩子,有则入队,直到队列空为止。 层次遍历挺简单,但是如果要输出结点...
  • 数据结构 二叉树层次遍历 C语言

    千次阅读 多人点赞 2018-12-19 16:21:08
    C语言 数据结构 二叉树层次遍历 原创作者:小林 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define max 100 typedef int ElemType; typedef struct BiTNode{ ElemType data; struct ...
  • 图30-1所示为二叉树层次遍历,即按照箭头所指方向,按照1,2,3,4的层次顺序,对二叉树中的各个结点进行访问。 图30-1 二叉树层次遍历 要进行层次遍历,需要借助一个队列。先将二叉树根结点入队,然后出队,...
  • 二叉树层次遍历--C语言

    千次阅读 多人点赞 2018-12-21 17:54:22
    今天写一下二叉树层次遍历层次遍历用到的数据结构是队列。   层次遍历算法中增加了三个int型数据,其中levelcount用于记录现在处理的是树的第几层;curlevel用于记录当前层还有几个节点没有被访问过;next...
  • 文章目录1 bfs2 dfs3 二叉树层次遍历 1 bfs   广度优先搜索(bfs) 和深度优先搜索都是的图的经典搜索算法之一,我们这里先给出一些模板。简单理解就是树的层次遍历,对于图的时候,也是按层,具体的就是节点与...
  • 在完全二叉树中,在层次遍历和先根序遍历中,已知某节点在一种遍历中的编号,求该节点在另一种遍历中的编号。 程序描述: q = 1表示已知某节点在先根序遍历中的编号,求的是它在层次遍历中的编号。 q = 2表示已知的...
  • 返回其层次遍历结果: [ [3], [9,20], [15,7] ] 每天记录一下,保证彻底掌握。 分析: 1.首先想要层次遍历,得清楚当前是哪一层,假如要输出第三层【4,5,7】,你得拿到【2,3】 2.访问【2】节点,搞一个容器装...
  • 二叉树层次遍历

    2016-09-26 09:57:04
    将图示的二叉树按照层次遍历,即得到遍历顺序为 8,6,10,5,7,9,11思想: 打印节点,如果该节点为空,则返回。 否则打印该节点,如果该节点存在孩子节点则存入队列,直到无孩子节点代码: 节点结构:class ...
  • 二叉树层次遍历(Java版)

    千次阅读 2018-09-23 16:32:06
    /** * Definition for a binary tree node. * public class TreeNode { * int val; * TreeNode left; * TreeNode right; * TreeNode(int x) { val = x; } * } */ class Solution { pub...
  • 二叉树层次遍历算法 #include <stdio.h> #include <alloc.h> #define MaxSize 1000 typedef char ElemType; typedef struct node { ElemType data; struct node *lchild; struct node *rchild; } BTNode; 创建二叉树...
  • 二叉树层次遍历(用队列实现)

    千次阅读 2019-08-18 17:21:24
    void BinaryTreeLevelOrder(BTNode* root)//用队列层次遍历 { Queue qu; BTNode* cur; QueueInit(&qu);//有初始化就要销毁 QueuePush(&qu, root);//根节点入队 while (!QueueIsEmpty(&qu)) { cur = ...
  • 二叉树层次遍历c++实现

    千次阅读 2017-07-19 08:07:04
    二叉树层次遍历c++实现
  • 思路:设置level变量记录层数,last变量记录该层最右结点,在层次遍历出队时,让队列的front指针与last对比,相等证明该层遍历完了,last=rear,同时level+1,直至遍历完成,即队列为空,此时level即为二叉树的高度...
  • 层次遍历用队列,但是如何记录层次是一个需要思考的地方。一种方法是提供两个变量记录本层节点数和下层节点数,还有一种很巧妙的方法,记录队列中元素的数量,就是当前层次节点数。 题解: 这道题思路是使用层次遍历...
  • 二叉树层次遍历(js)

    2020-09-23 08:49:56
    二叉树层次遍历(js)] //二叉树 var node4 = {left: null, right: null, val: 4 }; var node5 = {left: null, right: null, val: 5 }; var node6 = {left: null, right: null, val: 6 }; var node7 = {left: null, ...
  •  上面这个二叉树,那么层次遍历的输出应该是:1、2、3、4、5、6、7、8、9 2、解题思路  利用队列,依次将根,左子树,右子树存入队列,按照队列的先进先出规则来实现层次遍历。 3、编程实现 class Node(): #...
  • 二叉树层次遍历后输出 c++

    千次阅读 2018-08-01 13:17:18
    给定一个二叉树,返回其按层次遍历的节点值。 (即逐层地,从左到右访问所有节点)。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * ...
  • 给定一个二叉树,返回其节点值自底向上的层次遍历。 (即按从叶子节点所在层到根节点所在的层,逐层从左向右遍历) 例如: 给定二叉树 [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回其自底向上的...
  • 复习二叉树层次遍历和求树的宽度

    千次阅读 2018-07-10 21:33:17
    的#include &lt;stdio.h&gt;中 的#include &lt;iostream的&gt; 的#include &lt;stdlib.h&gt;中 使用命名空间std; #define MAXSIZE 100 typedef struct bnode ...} B节点,* bitree...
  • 二叉树层次遍历和深度遍历

    千次阅读 2015-09-26 17:21:23
    二叉树层次遍历和深度遍历 源码实现过程:
  • #include <stdio.h> #include <stdlib.h> #define MAX 100 struct treeNode { char data; struct treeNode* LChild; struct treeNode* RChild; }; struct treeNode* createNode(char data)... struct...
  • 考研复习整理之——二叉树层次遍历 1.思路 层次遍历,是指由左至右,由上之下,由层遍历一棵树。在层次遍历中,用到的不是递归,而是循环,通过建立一个队列,每次循环将所需遍历的结点出队并访问,然后再将改结点的...
  • 二叉树层次遍历 与二叉树先序、中序遍历使用栈类似,二叉树的层次遍历的实现是基于队列这个数据结构来实现的。 主要算法思想是首先建一个队列并将树的根节点入队,然后当树不为空的时候持续访问队首节点并将其左右...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 45,582
精华内容 18,232
关键字:

二叉树的层次遍历