二叉树的层次遍历(广度优先遍历)

广度优先遍历类似于二叉树的层次遍历 在计算机科学中,广度优先遍历(BFS)是一种用于遍历或搜索数据结构的算法。它从根节点开始,逐层地遍历该数据结构,先访问根节点的所有子节点,然后再依次访问子节点的子节点,以此类推,直到遍历完所有节点。广度优先遍历是一种常用的算法,它在许多应用中都有广泛的应用,例如图的遍历、最短路径算法等。在循环中,我们从队列的左侧弹出一个节点,并打印其值。然后,我们遍历该节点的子节点列表,并将每个子节点入队。我们将根节点入队,并使用一个循环来遍历队列中的节点。函数中,我们首先检查根节点是否为空,然后创建一个队列。 阅读详情
二叉树的层次遍历(广度优先遍历)
import java.util.*;   
  
public class BinaryTree {   
    protected Node root;   
  
    public BinaryTree(Node root) {   
        this.root = root;   
    }   
  
    public Node getRoot() {   
        return root;   
    }   
  
    /** 构造树 */  
    public static Node init() {   
        Node a = new Node('A');   
        Node b = new Node('B', null, a);   
        Node c = new Node('C');   
        Node d = new Node('D', b, c);   
        Node e = new Node('E');   
        Node f = new Node('F', e, null);   
        Node g = new Node('G', null, f);   
        Node h = new Node('H', d, g);   
        return h;// root   
    }   
  
    /** 访问节点 */  
    public static void visit(Node p) {   
        System.out.print(p.getKey() + " ");   
    }   
  
    /** 递归实现前序遍历 */  
     static void preorder(Node p) {   
        if (p != null) {   
            visit(p);   
            preorder(p.getLeft());   
            preorder(p.getRight());   
        }   
    }   
  
    /** 递归实现中序遍历 */  
     static void inorder(Node p) {   
        if (p != null) {   
            inorder(p.getLeft());   
            visit(p);   
            inorder(p.getRight());   
        }   
    }   
  
    /** 递归实现后序遍历 */  
     static void postorder(Node p) {   
        if (p != null) {   
            postorder(p.getLeft());   
            postorder(p.getRight());   
            visit(p);   
        }   
    }   
   /** 层次遍历*/
   static void levelorder(Node p){   
        if(p==null) return;   
        Queue< Node> queue=new LinkedList< Node>();   
        queue.offer(p);   
        while(queue.size()>0){   
            Node temp=queue.poll();   
            visit(temp); 
            if(temp.getLeft()!=null){   
                queue.offer(temp.getLeft());   
            }   
            if(temp.getRight()!=null){   
                queue.offer(temp.getRight());   
            }   
        }   
       
    }   
  
  
    // 求二叉树的高度
 static int height(Node tree) {
    if (tree == null)
	return 0;
    else {
	int leftTreeHeight = height(tree.getLeft());
	int rightTreeHeight = height(tree.getRight());;
	return leftTreeHeight > rightTreeHeight ? leftTreeHeight + 1: rightTreeHeight + 1;
    }
}
// 求二叉树的结点总数
  static int nodes(Node tree) {
   if (tree == null)
	return 0;
   else {
	int left = nodes(tree.getLeft());
	int right = nodes(tree.getRight());
	return left + right + 1;
  }
}
// 求二叉树叶子节点的总数
 static int leaf(Node tree) {
   if (tree == null)
	return 0;
   else {
	int left = leaf(tree.getLeft());
	int right = leaf(tree.getRight());
	if (tree.getLeft() == null && tree.getRight() == null)
		return left + right + 1;
	else
		return left + right;
    }
 }
//将二叉树所有结点的左右子树交换
static void swapTree(Node root){
  if(root != null) {
   Node tmp = root.getLeft();
   root.setLeft(root.getRight());
   root.setRight(tmp);
   swapTree(root.getLeft());
   swapTree(root.getRight());
  }
}
     /** 
     * getLeafNodes: 递归求解给定二叉树的所有叶子结点 
     * @param root   给定二叉树的根结点 
     * @param leaflist 给定二叉树的所有叶子结点 
     */  
  static void  getLeafNodes(Node root, List< Node> leaflist)  
    {  
        if (root != null) {  
            if (root.getLeft() == null && root.getRight() == null) {  
                leaflist.add(root);  
                return ;  
            }  
            getLeafNodes(root.getLeft(), leaflist);  
            getLeafNodes(root.getRight(), leaflist);  
        }  
    }  
  
  /** 
     * longestPath: 递归求解给定二叉树的一条最长路径 如果有多条,输出其中一条
     * @param root  给定二叉树的根结点 
     * @param longestPath 存放二叉树的最长路径上的结点 
     */  
    static void longestPath(Node root, List< Node> longestPath)  
    {  
        if (root != null) {  
            longestPath.add(root);  
            if (root.getLeft() == null && root.getRight() == null) { // 左右子树均空  
                 return ;  
            }  
         
                List< Node> leftLongestPath = new ArrayList< Node>();  
                List< Node> rightLongestPath = new ArrayList< Node>();  
                longestPath(root.getLeft(), leftLongestPath);  
                longestPath(root.getRight(), rightLongestPath);  
                if (leftLongestPath.size() >= rightLongestPath.size()) {  
                    longestPath.addAll(leftLongestPath);  
                } else if (leftLongestPath.size() < rightLongestPath.size()) {  
                    longestPath.addAll(rightLongestPath);  
                                
            }  
        }  
    }  
 
    /**  
     * @param args  
     */  
    public static void main(String[] args) {   
        BinaryTree tree = new BinaryTree(init());   
        System.out.print(" 前序遍历:");   
        preorder(tree.getRoot());   
        System.out.println();   
        System.out.print(" 中序遍历:");   
        inorder(tree.getRoot());   
        System.out.println();   
        System.out.print(" 后序遍历:");   
        postorder(tree.getRoot());   
        System.out.println(); 
        System.out.println(); 
       
        System.out.println("层次遍历");
        levelorder(tree.getRoot());
        System.out.println();   
        System.out.println();   
         System.out.println("叶子结点数");
         System.out.println(leaf(tree.getRoot()));
         System.out.println("总结点数");
         System.out.println(nodes(tree.getRoot()));
         System.out.println("树的高度");
         System.out.println(height(tree.getRoot()));
     
    }    
  
}  
public class Node {   
    private char key;   
    private Node left, right;   
  
    public Node(char key) {   
        this(key, null, null);   
    }   
  
    public Node(char key, Node left, Node right) {   
        this.key = key;   
        this.left = left;   
        this.right = right;   
    }   
  
    public char getKey() {   
        return key;   
    }   
  
    public void setKey(char key) {   
        this.key = key;   
    }   
  
    public Node getLeft() {   
        return left;   
    }   
  
    public void setLeft(Node left) {   
        this.left = left;   
    }   
  
    public Node getRight() {   
        return right;   
    }   
  
    public void setRight(Node right) {   
        this.right = right;   
    }   
} 
求二叉树的一条最长路径 NULL 博文链接:https://128kj.iteye.com/blog/1632218 立即下载

相关推荐

控制障碍函数(Control Barrier Function,CBF) 一、定义

介绍控制障碍函数

Lyajpunov的博客 2万+

二叉树的最长路径

求任意二叉树中第一条最长的路径长度,并输出此路径上各节点的值。

m0_62858660的博客 2984

从零到一:手把手教你用C#开发AGV调度系统(附避坑指南)

本文详细介绍了如何使用C#开发高效的AGV调度系统,涵盖从环境搭建到核心算法实现的完整流程。重点解析了动态路径规划、多机协同等关键技术,并提供了实用的避坑指南和性能优化建议,帮助开发者快速构建工业级车辆控制调度系统。

blockchain9miner的博客 743

求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值。

对于任意一棵二叉树,要求出第一条最长的路径长度并输出此路径上各结点的值,可以使用以下方法: 定义一个全局变量 maxLength,用于存储当前找到的最长路径长度。令 maxLength 的初始值为 0。 定义一个变量 path,用于存储当前找到的最长路径上各结点的值。 在二叉树的每个结点处,递归地求出以该结点为根的子树中最长的路径长度。具体地,对于当前结点的左子结点,求出以该左子结点为根的子...

weixin_35757531的博客 1482

Miniconda3迁移(附图详细过程)

服务器上目录占满,想要将conda迁移到其他目录下的操作方法,详细教程。

2301_77554343的博客 6948

从零开始:使用Remix和MetaMask在测试网部署智能合约的完整指南

本文提供了一份完整的指南,教你如何使用Remix和MetaMask在测试网上部署智能合约。从环境搭建、获取测试网代币到编写和部署合约,再到与合约交互和连接Python后端,涵盖了智能合约开发的各个环节。特别适合初学者快速上手区块链开发,同时介绍了安全注意事项和调试技巧。

weixin_29019241的博客 474

【数据结构与算法】求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值

求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值

知识虔诚的信徒,探索所有未知是信徒毕生的信仰 4595

Oracle EBS(R12+)通过Multi-Org 多组织架构、Multi-Ledger 多账簿、SLA 子分类账会计、多币种引擎、多会计政策并行五大核心能力,为跨国企业提供一体化、自动化、合规的

Oracle EBS(R12+)提供全球会计核算解决方案,通过Multi-Org多组织架构实现跨国集团数据隔离与共享,支持四层组织结构(业务组→法律实体→经营单位→库存组织)。Multi-Ledger多账簿功能允许一笔业务多准则自动核算,包含主账簿、辅助账簿和报告币种。系统内置多币种处理引擎,覆盖全流程货币业务,支持自动重估、再计量和折算。通过SLA子分类账会计实现多会计政策并行处理,满足不同国家会计准则和税制要求。该方案可同时支持本地法定、集团合并及管理分析需求,实现全球财务数据集中管理,提升合规性和运营

金牌架构师 554

求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值

求任意二叉树中第一条最长的路径长度,并输出此路径上各结点的值

xuhui000616的博客 1323

【002】C++ 语言核心:关键字深度解析与分类指南

auto:自动类型推导bool:布尔类型break:跳出循环或switch语句case:switch语句分支char:字符类型class:定义类const:常量continue:结束当前循环,开始下一次循环default:switch语句默认分支delete:删除对象do:do-while循环double:双精度浮点数类型else:if语句的否定分支enum:枚举类型explicit:显式构造函数export:导出符号extern:声明外部变量或函数。

Lion_Long的博客 1251

自监督学习原理与代码实战案例讲解

自监督学习原理与代码实战案例讲解 作者:禅与计算机程序设计艺术 1. 背景介绍 1.1 自监督学习的起源与发展 1.1.1 监督学习的局限性

AI天才研究院 626

二叉树最长路径的求解

题目描述 设二叉树中每个结点的元素均为一个字符,按先序遍历的顺序建立二叉链表,编写算法求出该二叉树中第一条最长的路径。 输入 多组数据。每组数据一行,为二叉树的先序序列(序列中元素为‘0’时,表示该结点为空)。当输入只有一个“0”时,输入结束。 输出 每组数据输出一行,第一行为二叉树的最长路径长度,第二行为此路径上从根到叶结点的各结点的值。 样例输入Copy abcd00e00f00ig00h00 abd00e00cf00g00 0 样例输出Copy 4 abcd 3 abd ...

m0_59884853的博客 4287

知识图谱中的 Ontology(本体论)

1980年,本体论(Ontology)哲学概念“本体”被引入到人工智能领域用来刻画知识。本体概念模型、明确、形式化、共享。本体是实体存在形式的描述,往往表示为一组概念定义和概念之间的层级关系,本体框架形式树状结构,通常被用来为知识图谱定义schema。如人、公司、车等都可以在具体场景下称为本体。Ontology是(特定领域)信息组织的一种形式,是领域知识规范的抽象和描述,是表达、共享、重用知识的方法。Ontology。

全网粉丝30W+,优快云、稀土掘金人工智能领域签约作者,人工智能、大模型、Python 爬虫,商务合作,请私信沟通。 2038

Algorithms_二叉树的层次遍历(广度优先)

文章目录使用树理解深度优先和广度优先 使用树理解深度优先和广度优先 我们上篇博文中 Algorithms_二叉树的前序遍历、中序遍历、后续遍历(深度优先) ,本质上是深度优先。 为什么这么说呢? 我们来看下 5 / \ 3 6 / \ \ 2 4 ...

小工匠 2万+

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

二叉树广度优先遍历(层次遍历)

宽度优先遍历,广度度优先遍历,层次遍历。 即从根节点开始依次遍历左子节点和右子节点,直到所有子节点都变遍历完为止。 遍历结果:{1,2,3,4,5,6,7,8,9,10 } leetcode练习: 思路: 将树上顶点按照层次依次放入队列结构中,队列中元素满足 FIFO(先进先出)的原则。 初始化队列只包含一个节点 root 和层次编号 0 : level = 0。 当队列非空的...

xuebaobao130526的博客 2042

C# WinForm 基于DirectShow.dll编写的程序,可边预览边保存视频,音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择(默认选中第一个)2.可录制wmv和avi两种格式的视频并且都带有音频,avi可以录制的分辨率和帧数进行选择,wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照,也可边录制视频边拍照4.添加了视频和音频的压缩功能(酌情使用)这次二次开发发现C#对DirectShow的相关信息太少,这次做完也不敢藏私共享出来,还望大家指正

二叉树广度优先遍历(层次遍历)及其应用

0.树结构 typedef struct BTNode { int data; struct BTNode *lchild; struct BTNode *rchild; }BTNode; 1.层次遍历 void level(BTNode *p) { if(!p)//空树直接返回 return; BTNode *q;//遍历树的指针 BTNode *que[maxSize];//...

qq_39024739的博客 581

二叉树的层次遍历使用广度优先

方法二: 使用队列的广度优先 class guangdu{ public List<List<Integer>> levelOrder(TreeNode root){ List<List<Integer>> list = new ArrayList<>(); if(root == null) return list; //队列的性质:先进先出,从头取,从尾添加 Queue<TreeNode> queue = ne

bxtx520的博客 227

二叉树层次遍历python_python 实现二叉树的深度&&广度优先遍历

概述前言什么是树什么是二叉树深度优先广度优先后记前言前面说到算法被虐了,这回我要好好把它啃下来。哪里跌倒就要从哪里站起来。这是我复习算法与数据结构时的小笔记,这里就 po 出来,给大家也复习一下旧的知识点,查缺补漏。如果我的文章对你有帮助,欢迎关注、点赞、转发,这样我会更有动力做原创分享。什么是树在计算器科学中,树(英语:tree)是一种抽象数据类型(ADT)或是实现这种抽象数据类型的数据结构,用...

weixin_39748445的博客 208

二叉树遍历(前序、中序、后序、层次、深度优先、广度优先遍历)

二叉树遍历一、前序遍历二、中序遍历三、后序遍历四、层次遍历五、深度与广度优先搜索 二叉树是一种非常重要的数据结构,非常多其他数据结构都是基于二叉树的基础演变而来的。对于二叉树,有深度遍历和广度遍历,深度遍历有前序、中序以及后序三种遍历方法,广度遍历即我们寻常所说的层次遍历。由于树的定义本身就是递归定义,因此採用递归的方法去实现树的三种遍历不仅easy理解并且代码非常简洁,而对于广度遍历来说,须要其...

Ternence_zq的博客 921

二叉树广度优先搜索、层次遍历

队列 实现广度搜索需要借助队列 Java队列的实现类为Queue. 方法 描述 boolean offer(E e) 入队,添加一个元素并返回true;如果队列已满,则返回false E poll() 出队,移除并返问队列头部的元素,如果队列为空,则返回null Queue接口与List、Set同一级别,都是继承了Collection接口。LinkedList实现了Queue接 口。Queue接口窄化了对LinkedList的方法的访问权限(即在方法中的参数类型如果是Queue时,就

二进制杯莫停的博客 1257

力扣题解-107. 二叉树的层次遍历 II(广度优先搜索)

广度优先搜索解决二叉树的层次遍历

lpp 5206

二叉树的层次遍历、二叉树求宽度、图的广度优先搜索

二叉树的层次遍历、二叉树求宽度、图的广度优先搜索 一类问题,层次遍历思想。 1. 二叉树的层次遍历 /* 1.将根结点入队 2.出队访问出队结点,若有左子树将左子树入队,若有右子树将右子树入队 循环2直到队空。 */ Status LevelOrder(BiTree T) { queue<BiTree> q; BiTree p; q.push(T); while (q.empty() == false) { p = q.front(); q.pop(); visit(p);

as_your_heart的博客 735

LeetCode二叉树的层次遍历Ⅱ(Python)——广度优先遍历

题目 解题思路 一开始看了题目,要求自底向上输出,第一反应是深度优先遍历,但仔细琢磨发现不对了,正如题中的例子,无论是前、中、后序遍历,都无法让15在9的前面被遍历到,没办法按题目想要的顺序输出(也可以强行用,后面说)。然后再看一眼题目,层次遍历?那就是要用广度优先遍历了。 广度优先遍历思路和104题二叉树最大深度的广度优先遍历很像,可以看这里。由于广度优先遍历没法直接自底向上式输出,所以最后要进行翻转,翻转这一步时间复杂度也为O(n);del这一步,由于是删除最后一个元素,不需要搬动其他元素,所以时间复

KeEN_Xwh的博客 376

二叉树的非递归遍历(树的深度优先遍历(根左右..)树的广度优先遍历(层次遍历))

二叉树的前序、中序、后序遍历我想大家应该都很熟悉了,那我们今天就来讲一下二叉树的层次遍历。

zhangmiaoping23的专栏 751

【剑指 offer】(二十三)—— 从上往下打印二叉树(或曰层次遍历、广度优先遍历)

从广度优先到深度优先,只差一个数据结构。 从上往下打印二叉树,实质是在考察树的遍历问题,显然不同于更为经典的先序、中序和后序遍历,而属于一种层次遍历,或曰广度优先遍历。二叉树节点的定义如下:struct BinaryTreeNode { int val; BinaryTreeNode* lft; BinaryTreeNode* rgt; };使用队列(FIFO)实现广度优先#

952

php二叉树广度优先遍历,PHP实现二叉树的深度优先遍历(前序、中序、后序)和广度优先遍历(层次)...

PHP实现二叉树的深度优先遍历(前序、中序、后序)和广度优先遍历(层次)青春阳光king 码农编程进阶笔记前言:深度优先遍历:对每一个可能的分支路径深入到不能再深入为止,而且每个结点只能访问一次。要特别注意的是,二叉树的深度优先遍历比较特殊,可以细分为先序遍历、中序遍历、后序遍历。具体说明如下:前序遍历:根节点->左子树->右子树中序遍历:左子树->根节点->右子树后序遍...

weixin_35693911的博客 271
上一篇: Android-View-Animation 编辑框抖动shake
下一篇: A Visual Git Reference
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值