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

    2014-10-24 12:14:16
    层次遍历二叉树
  • 实现二叉树类,包含层次遍历、调试工程 按照普通的二叉树输入方法进行输入,空节点还是用@表示。 例如输入以下这棵树: A / \ B C / \ D E / \ F G 输入根节点:A 输入A的两个儿子(@表示空节点):BC 输入B的两...
  • 层次遍历

    千次阅读 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 struc
    展开全文
  • 前言 树是数据结构中非常重要的一种,主要的用途是用来... 队列实现层次遍历 # -*- coding=utf-8 -*- class Node(object): """节点类""" def __init__(self, element=-1, l_child=None, r_child=None): self.eleme
  • 二叉树的层次遍历

    千次阅读 2021-02-03 20:51:19
    一、层次遍历 层次遍历即为从上到下,从左到右依次访问二叉树的每个结点。 二、层次遍历实现 1、实现思路 (1)我们定义一个队列,先将根结点入队; (2)当前结点是队头结点,将其出队并访问; (3)若当前结点的...

    一、层次遍历

    层次遍历即为从上到下,从左到右依次访问二叉树的每个结点

    二、层次遍历实现

    1、实现思路

    (1)我们定义一个队列,先将根结点入队;
    (2)当前结点是队头结点,将其出队并访问;
    (3)若当前结点的左结点不为空将左结点入队;若当前结点的右结点不为空将其入队即可。

    2、实现代码

    public class LevelOrder {
    	static List<Integer> levellist=new ArrayList<>();
    	public static void levelorder(TreeNode root) {
    		if(root==null) {//空树
    			return;
    		}
    		Queue<TreeNode> queue=new LinkedList<>();
    		queue.offer(root);//offer方法表示添加元素到队尾
    		while(!queue.isEmpty()) {
    			TreeNode temp=queue.poll();//poll方法删除队头元素
    			levellist.add(temp.val);
    			if(temp.left!=null) {
    				queue.offer(temp.left);
    			}
    			if(temp.right!=null) {
    				queue.offer(temp.right);
    			}
    		}
    	}
    

    三、完整代码实现

    package Tree;
    
    import java.util.ArrayList;
    import java.util.LinkedList;
    import java.util.List;
    import java.util.Queue;
    
    class TreeNode {//二叉树结点定义
        int val;
        TreeNode left;
        TreeNode right;
    
        TreeNode(int x) {
            val = x;
        }
    }
    
    public class LevelOrder {
    	static List<Integer> levellist=new ArrayList<>();
    	public static void levelorder(TreeNode root) {
    		if(root==null) {//空树
    			return;
    		}
    		Queue<TreeNode> queue=new LinkedList<>();
    		queue.offer(root);//offer方法表示添加元素到队尾
    		while(!queue.isEmpty()) {
    			TreeNode temp=queue.poll();//poll方法删除队头元素
    			levellist.add(temp.val);
    			if(temp.left!=null) {
    				queue.offer(temp.left);
    			}
    			if(temp.right!=null) {
    				queue.offer(temp.right);
    			}
    		}
    	}
    	public static void main(String[] args) {
    		TreeNode root=new TreeNode(7);//创建二叉树
    		TreeNode a=new TreeNode(4);
    		TreeNode b=new TreeNode(9);
    		TreeNode c=new TreeNode(2);
    		TreeNode d=new TreeNode(5);
    		TreeNode e=new TreeNode(8);
    		TreeNode f=new TreeNode(11);
    		TreeNode g=new TreeNode(1);
    		TreeNode h=new TreeNode(3);
    		TreeNode i=new TreeNode(10);
    		TreeNode j=new TreeNode(12);
    		root.left=a;
    		root.right=b;
    		a.left=c;
    		a.right=d;
    		b.left=e;
    		b.right=f;
    		c.left=g;
    		c.right=h;
    		f.left=i;
    		f.right=j;
    		
    		levelorder(root);//层次遍历
    		for(int m=0;m<levellist.size();m++) {
    			System.out.print(levellist.get(m)+" ");
    		}
    	}
    }
    
    

    运行结果:

    7 4 9 2 5 8 11 1 3 10 12 
    

    该实例的二叉树图如下图所示:
    在这里插入图片描述
    PS:
    java.util.Queue接口,用以支持队列的常见操作。该接口扩展了java.util.Collection接口。但Queue使用时要尽量避免Collection的add()和remove()方法一般我们使用offer()和poll()来对队列进行添加删除元素

    队列是一种特殊的线性表,它只允许在表的前端进行删除操作,而在表的后端进行插入操作。LinkedList类实现了Queue接口,因此我们可以把LinkedList当成Queue来用

    Queue的部分方法:
    在这里插入图片描述

    展开全文
  • 二叉树遍历算法 (递归的、非递归的中序、前序、后序遍历 和 层次遍历 以及 求二叉树的宽度和深度)
  • 实验三 二叉树的建立和层次遍历 一 实验目的 掌握二叉树的原理、表示及实现方法。 掌握二叉树的基本操作,二叉树的建立、遍历方法。 二 实验要求 认真设计本实验的程序,上机调试运行本程序。 保存或打印出程序的...
  • Java实现二叉树的先序、中序、后续、层次遍历,经验证可用版本,方便各种找工作面试笔试
  • 二叉树层次遍历算法

    千次阅读 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;
    }
    
    展开全文
  • c代码-二叉树的层次遍历(队列实现)
  • 用c语言实现对二叉树的层次遍历求其节点和树的深度
  • 二叉树层次遍历算法——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 <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
    在这里插入图片描述

    展开全文
  • NULL 博文链接:https://sun810.iteye.com/blog/1261373
  • 数据结构中的层次遍历问题,简单的代码,不需要重复的遍历,时间复杂度较低
  • Java 二叉树层次遍历

    千次阅读 2020-06-06 16:28:41
    Java 二叉树层次遍历
  • 层次遍历是把树看成从上到下的若干层:根结点在第一层,根结点的孩子在第二层,根结点的孩子的孩子在第三层,然后依次类推,从上到下一层一层来访问,每一层从左到右依次访问,每个结点只访问一次 如何实现?...
  • 二叉树非递归遍历非递归的后序遍历二叉树 //非递归的后续遍历二叉树 void HXprint(Tree *tree){ Stack s = initStack(); //初始化一个下面使用的栈 treeNode *p = tree; //新建一个遍历指针 treeNode *r=NULL;...
  • 非递归版的层次遍历,简单易懂!!!
  • 1.二叉树层次遍历 2.二叉树结构图的打印 结语 1.二叉树层次遍历 主要用到队列操作,先入队根结点,再不断出队,判断出队结点是否有左右孩子,有则入队,直到队列空为止。 层次遍历挺简单,但是如果要输出结点...
  • 树的层次遍历

    万次阅读 多人点赞 2019-02-15 14:44:47
    二叉树的前序、中序、后序遍历我想大家应该都很熟悉了,那我们今天就来讲一下二叉树的层次遍历。 二叉树的前序、中序、后序遍历需要用到栈(递归的过程也就是一个栈),层次遍历需要借助队列这个数据结构。 层次...
  • 儿子兄弟链表存储的二叉树,其前序、后序、层次遍历实现
  • 中序遍历和层次遍历构造二叉树

    千次阅读 2020-02-19 11:11:51
    题目:层次遍历和中序遍历构建二叉树 算法思想:InOrder, LevelOrder 分别存储中序序列和层变遍历序列,用cnt1记录层次遍历序列插入结点的下标,[low, high]为插入结点在中序序列的范围,插入LevelOrder[cnt1] ...
  • 采用循环队列解决二叉树的层次遍历: 思路:对成功创建的二叉链树进行层次遍历,这里采用循环队列的思想来解决,主要是从根节点开始,将结点进队(下标rear+1,接着进队),然后(front + 1)将元素出对,此时,对出...
  • C语言层次遍历二叉树

    2011-07-04 22:04:55
    C语言详细介绍二叉树,及其遍历方法。值得学习
  • 层次遍历是树的第四种遍历方式,使用队列,可以认为是广度优先搜索在树的应用。 目录 1.生成本文例子中的树 2.层次遍历方式-使用队列 3.完整代码 1.生成本文例子中的树 本文中创建的树如下: 其层次遍历...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 153,176
精华内容 61,270
关键字:

层次遍历