二叉树的遍历

最新推荐文章于 2024-11-09 12:43:52 发布
最新推荐文章于 2024-11-09 12:43:52 发布
阅读量161 收藏
点赞数 1
分类专栏： 数据结构与算法 文章标签： java 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46085251/article/details/128476261
版权

为什么要使用树的结构？

对于一个同类型的数据集合我们常常会使用数组或者链表的数据结构来存储数据，但无论是链表还是数组都有它的优缺点。

  1. 数组：
    对于数组来说，它在定义的那一刻就要决定它的长度，但很多情况我们是不清楚要定义多长的数组的，因此就有了数组扩容的策略，像java的ArrayList就是，在存储的数据达到最大限度时，此时添加一个数据就会新建一个数组（长度按特定的策略来定，比如原数组的两倍）把原数组的数据（直接把全部数据拷贝到新数组）和新添的数据放入到新数组。
    数组的优点就是检索方便（在连续的存储空间存放，只需根据下标即可快速检索某一个元素），但在特定的位置添加元素需要把部分数据移动才能添加（尾插还是方便的）和它需要固定长度。
  2. 链表
    对于链表来说它不需要指定长度，它的节点可以在不连续的内存存放
    ，但是它检索某一个元素需要遍历整个链表，这个对比数组就显得很慢了。
    链表的优点就是插入数据方便，只需要改变一下节点间的指针指向（即每个节点相连的那条链）即可。
  3. 树
    树就解决了数组和链表存在的问题，它插入跟链表类似，只需要在特定的节点改变指针的指向即可。检索某一个存在的数据也不需要全部节点都遍历，尤其对于有序的二叉树，根节点的左右节点分别比它小和大，很快就能找到。

二叉树结构图

图1.1
查找 关胜节点 后序查找的顺序：吴用->关胜 只需要查找两次就能找到

二叉树的前中后序遍历

（我认为无论前序、中序、后续的遍历都是相对于父节点来的）

  1. 前序遍历
    1.1前序就先输出当前节点。
    1.2再遍历它的左子树。
    1.3最后遍历它的右子树。
    对应图1.1的顺序：1->2->3->5->4
    /**
     * 前序遍历
     * @param root 根节点
     */
    public void preOrder(HeroNode root){
    //	判断根节点是否为空
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }
        //1.输出当前节点
        System.out.println(root);
        //2.遍历左子树
        if (root.left!=null){
            preOrder(root.left);
        }
        //3.遍历右子树
        if (root.right!=null){
            preOrder(root.right);
        }
    }
    /**
     * 前序查找
     * @param root 根节点
     * @param no 查找节点的序号
     * @return 返回找到的节点
     */
    public HeroNode preSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }
//        比较当前节点
        if (root.no == no){
            return root;
        }
        HeroNode result = null;
//        查找左子树
        if (root.left!=null){
            result = preSearch(root.left,no);
        }
//		  若在左子树里找到就结束     
        if (result != null){
            return result;
        }
//        查找右子树
        if (root.right!=null){
            result = preSearch(root.right,no);
        }
        return result;
    }
  1. 中序遍历
    2.1先遍历当前节点的左子树。
    2.2再输出当前节点。
    2.3最后遍历当前的右子树。
    对应图1.1的顺序：2->1->5->3->4
//    中序遍历
    public void infixOrder(HeroNode root){
    	// 判断根节点是否为空
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }
		// 1.遍历左子树
        if (root.left!=null){
            infixOrder(root.left);
        }
		// 2.输出当前节点
        System.out.println(root);
  		// 3.遍历右子树
        if (root.right!=null){
            infixOrder(root.right);
        }
    }
    /**
     * 中序查找
     * @param root 根节点
     * @param no 查找节点的序号
     * @return 返回找到的节点
     */
    public HeroNode infixSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }

        HeroNode result = null;
    //        查找左子树
        if (root.left!=null){
            result = infixSearch(root.left,no);
        }
        if (result != null){
            return result;
        }

        System.out.println("中序查找");
        //        比较当前节点
        if (root.no == no){
            return root;
        }

    //        查找右子树
        if (root.right!=null){
            result = infixSearch(root.right,no);
        }
        if (result!=null){
            return result;
        }
        return null;
    }
  1. 后序遍历
    3.1先遍历当前节点的左子树。
    3.2最后遍历当前的右子树。
    3.3再输出当前节点。
    对应图1.1的顺序：2->5->4->3->1
//    后续遍历
    public void postOrder(HeroNode root){
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }
		//1.遍历左子树
        if (root.left!=null){
            postOrder(root.left);
        }
		//2.遍历右子树
        if (root.right!=null){
            postOrder(root.right);
        }
        //3.输出当前节点
        System.out.println(root);
    }
    /**
     * 后序查找
     * @param root 根节点
     * @param no 查找节点的序号
     * @return 返回找到的节点
     */
    public HeroNode postSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }

        HeroNode result = null;
        //        查找左子树
        if (root.left!=null){
            result = postSearch(root.left,no);
        }
        if (result != null){
            return result;
        }

        //        查找右子树
        if (root.right!=null){
            result = postSearch(root.right,no);
        }
        if (result!=null){
            return result;
        }

        System.out.println("后序查找");
        //        比较当前节点
        if (root.no == no){
            return root;
        }
        return null;
    }

节点的删除：
这里直接删除对应节点及其左右子树
1.判断要删除的是否是根节点。
2.若不是根节点，判断当前节点的左右子节点是否是要删除的节点，是直接把当前节点的左子节点或者右子节点置空即可。
3.若当前节点的左右子节点都不是要删除的节点，递归遍历当前节点的左子树判断是否在左子树。
4.若要删除节点不在左子树，继续递归遍历右子树，判断是否在右子树

//    删除节点（可以看下面的全部代码）
    public boolean del(int no){
//        判断是否删除的是根节点
        if (root!=null){
            if (root.no == no){
                root = null;
                return false;
            }else {
          	// 遍历根节点的左右子树
                return root.del(no);
            }
        }else {
            return false;
        }
    }
}

    public boolean del(int no){
//        删除的是否是当前节点的左子节点
        if (this.left != null && this.left.no == no){
            this.left = null;
            return true;
        }
//        删除的是否是当前节点的右子节点
        if (this.right != null && this.right.no == no){
            this.right = null;
            return true;
        }

//        向左子树查找目标删除
        if (this.left!=null && this.left.del(no)){
            return true;
        }else return this.right != null && this.right.del(no);
//        向右子树查找目标删除
    }

全部代码：

二叉树：
class BinaryTree{
    public HeroNode root;

//    前序遍历
    public void preOrder(HeroNode root){
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }
        System.out.println(root);
        if (root.left!=null){
            preOrder(root.left);
        }
        if (root.right!=null){
            preOrder(root.right);
        }
    }

//    前序查找
    public HeroNode preSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }
        System.out.println("前序查找");
//        比较当前节点
        if (root.no == no){
            return root;
        }
        HeroNode result = null;
//        查找左子树
        if (root.left!=null){
            result = preSearch(root.left,no);
        }
        if (result != null){
            return result;
        }
//        查找右子树
        if (root.right!=null){
            result = preSearch(root.right,no);
        }
        return result;
    }

//    中序遍历
    public void infixOrder(HeroNode root){
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }

        if (root.left!=null){
            infixOrder(root.left);
        }

        System.out.println(root);

        if (root.right!=null){
            infixOrder(root.right);
        }
    }
//    中序查找
    public HeroNode infixSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }

        HeroNode result = null;
    //        查找左子树
        if (root.left!=null){
            result = infixSearch(root.left,no);
        }
        if (result != null){
            return result;
        }

        System.out.println("中序查找");
        //        比较当前节点
        if (root.no == no){
            return root;
        }

    //        查找右子树
        if (root.right!=null){
            result = infixSearch(root.right,no);
        }
        if (result!=null){
            return result;
        }
        return null;
    }

//    后续遍历
    public void postOrder(HeroNode root){
        if (root==null){
            System.out.println("二叉树为空！");
            return;
        }

        if (root.left!=null){
            postOrder(root.left);
        }

        if (root.right!=null){
            postOrder(root.right);
        }
        System.out.println(root);
    }
//    后序查找
    public HeroNode postSearch(HeroNode root,int no){
        if (root==null){
            System.out.println("二叉树为空");
            return null;
        }

        HeroNode result = null;
        //        查找左子树
        if (root.left!=null){
            result = postSearch(root.left,no);
        }
        if (result != null){
            return result;
        }

        //        查找右子树
        if (root.right!=null){
            result = postSearch(root.right,no);
        }
        if (result!=null){
            return result;
        }

        System.out.println("后序查找");
        //        比较当前节点
        if (root.no == no){
            return root;
        }
        return null;
    }

//    删除节点
    public boolean del(int no){
//        判断是否是删除根节点
        if (root!=null){
            if (root.no == no){
                root = null;
                return false;
            }else {
                return root.del(no);
            }
        }else {
            return false;
        }
    }
}

树节点基本的结构
class HeroNode {
    public int no;
    public String name;
    public HeroNode left;
    public HeroNode right;

    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

// 删除节点
    public boolean del(int no){
//        删除的是否是左子节点
        if (this.left != null && this.left.no == no){
            this.left = null;
            return true;
        }
//        删除的是否是右子节点
        if (this.right != null && this.right.no == no){
            this.right = null;
            return true;
        }

//        向左子树查找目标删除
        if (this.left!=null && this.left.del(no)){
            return true;
        }else return this.right != null && this.right.del(no);
//        向右子树查找目标删除
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\''  +
                '\'' +
                '}';
    }
}

运行程序：

       // 构建二叉树
        HeroNode root = new HeroNode(1,"宋江");
        HeroNode node2 = new HeroNode(2,"吴用");
        HeroNode node3 = new HeroNode(3,"卢俊义");
        HeroNode node4 = new HeroNode(4,"林冲");
        HeroNode node5 = new HeroNode(5,"关胜");
        root.left = node2;
        root.right = node3;
        node3.right = node4;
        node3.left = node5;
        BinaryTree binaryTree = new BinaryTree();
        binaryTree.root = root;

        System.out.println("前序遍历：");
        binaryTree.preOrder(binaryTree.root);
        System.out.println("中序遍历：");
        binaryTree.infixOrder(binaryTree.root);
        System.out.println("后序遍历：");
        binaryTree.postOrder(binaryTree.root);
        
//        查找
        System.out.println("查找序号为 5 的节点："+binaryTree.preSearch(root, 5));
        System.out.println("查找序号为 100 的节点："+binaryTree.infixSearch(root, 100));
        System.out.println("查找序号为 5 的节点："+binaryTree.postSearch(root, 5));
//      删除节点
        System.out.println("del前：");
        binaryTree.preOrder(binaryTree.root);
        System.out.println(binaryTree.del(5)?"成功删除":"删除失败，没有该节点！");
        System.out.println("del后：");
        binaryTree.preOrder(binaryTree.root);

结果：
在这里插入图片描述
在这里插入图片描述

仅仅是个人理解，有不对的地方欢迎大佬指出。

二叉树遍历方法——前、中、后序遍历（图解）
在夜里行走的博客
11-04 15万+
二叉树的前、中、后序遍历的递归与非递归算法
二叉树遍历顺序
weixin_49725030的博客
07-12 908
二叉树的遍历方式有三种：先序遍历、中序遍历和后序遍历 等。
一文搞懂二叉树遍历---超详解（二叉树逐步剖析二）
热门推荐
weixin_64067830的博客
04-27 5万+
二叉树遍历一文搞懂，快过来看看吧
二叉树遍历方法——前、中、后序遍历（java）
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
二叉树遍历详解
码农笔记
01-16 5221
二叉树的遍历方式是最基本，也是最重要的一类题目，我们将从「前序」、「中序」、「后序」、「层序」四种遍历方式出发，总结他们的递归和迭代解法。 一、二叉树定义 二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个结点最多只能有两棵子树，且有左右之分。简单来说，就是一个包含节点，以及它的左右孩子的一种数据结构 假设二叉树的节...
易语言二叉树遍历
07-21
二叉树遍历是理解数据结构和算法的基础，它包括前序遍历、中序遍历和后序遍历三种主要方法。 1. **二叉树的基本概念**： - 二叉树是一种特殊的树结构，每个节点最多有两个子节点，通常称为左子节点和右子节点。 -...
【C语言二叉树遍历实例】C语言二叉树遍历实例
05-20
二叉树的遍历C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历实例C语言二叉树遍历...
matlab实现二叉树遍历算法（源代码）
04-30
### MATLAB 实现二叉树遍历算法的知识点详解 #### 一、二叉树节点结构体定义 在MATLAB中实现二叉树的第一步是定义一个表示二叉树节点的结构体。在这个例子中，作者定义了一个名为`TreeNode`的类来表示节点，该类...
二叉树遍历流程图（先序、中序、后序、宽度遍历）
05-01
二叉树遍历是计算机科学中处理树结构数据时常用的一种技术，主要分为四种类型：先序遍历、中序遍历、后序遍历和宽度优先遍历。这些遍历方法各有特点，适用于不同的场景。 1. **先序遍历**： - **递归实现**：先...
JAVA-01-变量
LJH_laura_li的博客
11-08 254
在方法、构造函数或块内部定义的变量。
2024年华为OD机试真题-查找充电设备-C++-OD统一考试（E卷）
面试高手的博客
11-08 124
某个充电站，可提供n个充电设备只，每个充电设备均有对应的输出功率任意个充电设备组合的输出功率总和，均构成功率集合P的1个元素功率集合P的最优元素，表示最接近充电站最大输出功率pmax 的元素。每一题都含有详细的解题思路和代码注释，精编c++、JAVA、Python三种语言解法。当充电设备输出功率50、20、20组合时，其输出功率总和为90，最接近充电站最大充电输出功率，因此最优元素为90。所有充电设备的输出功率组合，均大于充电站最大充电输出功率30，此时最优元素值为0。第 2 行为每个充电设备的输出功率。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 479
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
Java基于小程序公考学习平台的设计与实现（附源码，文档）
最新发布
chusheng1840的博客
11-09 467
Java基于小程序公考学习平台的设计与实现，小程序公考学习平台使用Java语言进行编码，使用Mysql创建数据表保存本系统产生的数据。系统可以提供信息显示和相应服务，其管理小程序公考学习平台信息，查看小程序公考学习平台信息，管理小程序公考学习平台。总之，小程序公考学习平台集中管理信息，有着保密性强，效率高，存储空间大，成本低等诸多优点。它可以降低信息管理成本，实现信息管理计算机化。关键词：小程序公考学习平台；Java语言；Mysql。
【Java知识】Java基础-对象排序的实现
wendao76的专栏
11-04 429
方法，并且需要提供一个比较器（Comparator）来定义对象的排序逻辑。这些示例展示了如何在Java中对对象进行排序，无论是使用列表还是数组，都可以灵活地使用比较器来定义排序规则。在Java中，对象的排序通常涉及到使用。
greendao使用封装
白高林的专栏
11-07 425
greenDAO
【JAVA】Java基础—面向对象编程基础：类与对象的概念
thinking_chou的专栏
11-07 1019
类是一个用户定义的数据类型，它包含了属性和方法。属性用于描述对象的特征，方法用于描述对象的行为。类与对象是Java编程的核心概念。类是对象的蓝图，定义了对象的属性和方法；对象是类的实例，具有独立的状态和行为。通过类与对象，我们可以更好地模拟现实世界中的事物，使得程序设计更加清晰和模块化。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值