：二叉树案例

最新推荐文章于 2022-06-08 16:39:49 发布
最新推荐文章于 2022-06-08 16:39:49 发布
阅读量285 收藏 1
点赞数
分类专栏： 学习过程 文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shlr_/article/details/124988084
版权

 

目录

1： 求序列问题

2：查找与删除功能

  1. 前序遍历: 先输出父节点， 再遍历左子树和右子树
  2. 中序遍历: 先遍历左子树， 再输出父节点， 再遍历右子树
  3. 后序遍历: 先遍历左子树， 再遍历右子树， 最后输出父节点

1： 求序列问题

 答案：ABCDGEIHFJK

绘图如下：

package com.atguigu.tree;
 
public class linshi {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
      HeroNode root = new HeroNode(1, "A");
      HeroNode node2 = new HeroNode(2, "B");
      HeroNode node3 = new HeroNode(3, "I");
      HeroNode node4 = new HeroNode(4, "C");
      HeroNode node5 = new HeroNode(5, "G");
      HeroNode node6 = new HeroNode(6, "H");
      HeroNode node7 = new HeroNode(7, "J");
      HeroNode node8 = new HeroNode(8, "D");
      HeroNode node9 = new HeroNode(9, "E");
      HeroNode node10 = new HeroNode(10, "F");
      HeroNode node11 = new HeroNode(11, "K");
      
      root.setLeft(node2);
      root.setRight(node3);
      node2.setLeft(node4);
      node2.setRight(node5);
      node3.setLeft(node6);
      node3.setRight(node7);
      node4.setLeft(node8);
      node5.setRight(node9);
      node6.setRight(node10);
      node7.setRight(node11);
      binaryTree.setRoot(root);
 
        System.out.println("前序遍历");
        binaryTree.preOrderEntity();
        System.out.println("中序遍历");
        binaryTree.infixOrderEntity();
        System.out.println("后序遍历");
        binaryTree.postOrderEntity();
    }
}
 
class BinaryTree{
    private HeroNode root; //根节点
    public void setRoot(HeroNode root){
        this.root = root;
    }
    //前序遍历
    public void preOrderEntity(){
        if(this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //中序遍历
    public void infixOrderEntity(){
        if(this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    //后序遍历
    public void postOrderEntity(){
        if(this.root != null){
            this.root.postOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
}
class HeroNode{
    private int no;
    private String name;
    private HeroNode left; 
    private HeroNode right;
    public HeroNode(int no, String name){
        this.no = no;
        this.name = name;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public HeroNode getLeft() {
        return left;
    }
    public void setLeft(HeroNode left) {
        this.left = left;
    }
    public HeroNode getRight() {
        return right;
    }
    public void setRight(HeroNode right) {
        this.right = right;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
    //前序遍历的方法
    public void preOrder(){
        System.out.println(this);  //先输出父节点
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.preOrder();
        }
    }
    //中序遍历的方法
    public void infixOrder(){
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.infixOrder();
        }
        System.out.println(this);  //先输出父节点
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.infixOrder();
        }
    }
    //后序遍历的方法
    public void postOrder(){
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.postOrder();
        }
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.postOrder();
        }
        System.out.println(this);  //先输出父节点
    }
}

 

2：查找与删除功能

 

代码演示删除3号节点下子树 

package com.atguigu.tree;
 
public class BinaryTreeDemo {
    public static void main(String[] args) {
        //创建一个二叉树
        BinaryTree binaryTree = new BinaryTree();
        //创建需要的结点
        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.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);
        binaryTree.setRoot(root);
 
//        System.out.println("前序遍历");//1 2 3 5 4
//        binaryTree.preOrderEntity();
//        System.out.println("中序遍历");//2 1 5 3 4
//        binaryTree.infixOrderEntity();
//        System.out.println("后序遍历");//2 5 4 3 1
//        binaryTree.postOrderEntity();
        //前序查找  4次
//        System.out.println("前序查找");
//        HeroNode resNode = binaryTree.preOrderSearch(5);
//        if(resNode != null) {
//        	System.out.printf("找到了，no: %d name: %s ",resNode.getNo(),resNode.getName());
//        }else {
//        	System.out.printf("没找到，no为 %d 的英雄 ",5);
//        }
        //中序遍历 3次
//        System.out.println("中序查找");
//        HeroNode resNode = binaryTree.infixOrderSearch(5);
//        if(resNode != null) {
//        	System.out.printf("找到了，no: %d name: %s ",resNode.getNo(),resNode.getName());
//        }else {
//        	System.out.printf("没找到，no为 %d 的英雄 ",5);
//        }
        //后序遍历 2次
//      System.out.println("后序查找");
//      HeroNode resNode = binaryTree.postOrderSearchEntity(5);
//      if(resNode != null) {
//      	System.out.printf("找到了，no: %d name: %s ",resNode.getNo(),resNode.getName());
//      }else {
//      	System.out.printf("没找到，no为 %d 的英雄 ",5);
//      }
 
        

        //测试删除节点功能
        System.out.println("删除前，前序遍历~");
        binaryTree.preOrderEntity();// 1 2 3 5 4
//        binaryTree.delNodeEntity(5);
        binaryTree.delNodeEntity(3);
        System.out.println("删除之后，前序遍历~");
        binaryTree.preOrderEntity();// 1 2 3 4

    }
    
}
 
//定义一个二叉树
class BinaryTree{
    private HeroNode root; //根节点
 
    public void setRoot(HeroNode root){
        this.root = root;
    }
    
    //删除节点
    public void delNodeEntity(int no) {
    	if(root!=null) {
    		//如果只有一个root结点，这里立即判断root是不是要删除的节点
    		if(root.getNo()==no) {
    			root = null;
    		}else {
    			//递归删除
    			root.delNode(no);
    		}
    	}else {
    		System.out.println("空树，不能删除~~");
    	}
    }
 
    //前序遍历
    public void preOrderEntity(){
        if(this.root != null){
            this.root.preOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
 
    //中序遍历
    public void infixOrderEntity(){
        if(this.root != null){
            this.root.infixOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
 
    //前序遍历
    public void postOrderEntity(){
        if(this.root != null){
            this.root.postOrder();
        }else{
            System.out.println("二叉树为空，无法遍历");
        }
    }
    
    //前序查找
    public HeroNode preOrderSearchEntity(int no) {
    	if(root != null) {
    		return root.preOrderSearch(no);
    	}else {
    		return null;
    	}
    }
    //中序查找
    public HeroNode infixOrderSearchEntity(int no) {
    	if(root != null) {
    		return root.infixOrderSearch(no);
    	}else {
    		return null;
    	}
    }
    //后序查找
    public HeroNode postOrderSearchEntity(int no) {
    	if(root != null) {
    		return root.postOrderSearch(no);
    	}else {
    		return null;
    	}
    }
}
 
//先创建HeroNode 结点
class HeroNode{
    private int no;
    private String name;
    private HeroNode left; //默认为null
    private HeroNode right;
 
    public HeroNode(int no, String name){
        this.no = no;
        this.name = name;
    }
 
    public int getNo() {
        return no;
    }
 
    public void setNo(int no) {
        this.no = no;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public HeroNode getLeft() {
        return left;
    }
 
    public void setLeft(HeroNode left) {
        this.left = left;
    }
 
    public HeroNode getRight() {
        return right;
    }
 
    public void setRight(HeroNode right) {
        this.right = right;
    }
    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
 //递归删除节点
    public void delNode(int no) {
    	if(this.left!=null && this.left.no==no) {
    		this.left = null;
    		return;
    	}
    	if(this.right!=null && this.right.no==no) {
    		this.right = null;
    		return;
    	}
    	if(this.left != null) {
    		this.left.delNode(no);
    	}
    	if(this.right != null) {
    		this.right.delNode(no);
    	}
    }
    //前序遍历的方法
    public void preOrder(){
        System.out.println(this);  //先输出父节点
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.preOrder();
        }
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.preOrder();
        }
    }
    //中序遍历的方法
    public void infixOrder(){
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.infixOrder();
        }
        System.out.println(this);  //先输出父节点
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.infixOrder();
        }
    }
    //后序遍历的方法
    public void postOrder(){
        //递归向左子树前序遍历
        if(this.left != null){
            this.left.postOrder();
        }
        //递归向右子树前序遍历
        if(this.right != null){
            this.right.postOrder();
        }
        System.out.println(this);  //先输出父节点
    }
    
    //前序查找 根据no查找
    /**
     * @param no 查找no
     * @return 如果找到就返回Node，否则返回null
     */
    public HeroNode preOrderSearch(int no) {
    	System.out.println("进入前序遍历~~");
    	//比较当前节点
    	if(this.no == no) {
    		return this;
    	}
    	//判断左子节点是否空，递归查询,找到返回
    	HeroNode resNode = null;//临时变量
    	if(this.left != null) {
    		resNode = this.left.preOrderSearch(no);
    	}
    	if(resNode != null) {//为真说明找到
    		return resNode;
    	}
    	//左子树未找到，递归右子树
    	if(this.right != null) {
    		resNode = this.right.preOrderSearch(no);
    	}
    	return resNode;
    }
    
    //中序查找 根据no查找
    public HeroNode infixOrderSearch(int no) {
    	//判断左子节点是否空，递归查询,找到返回
    	HeroNode resNode = null;//临时变量
    	if(this.left != null) {
    		resNode = this.left.infixOrderSearch(no);
    	}
    	if(resNode != null) {//为真说明找到
    		return resNode;
    	}
    	System.out.println("进入中序查找~~");
    	//比较当前节点
    	if(this.no == no) {
    		return this;
    	}
    	//左子树未找到，递归右子树
    	if(this.right != null) {
    		resNode = this.right.infixOrderSearch(no);
    	}
    	return resNode;
    }
    
    //后序查找 根据no查找
    public HeroNode postOrderSearch(int no) {
    	//判断左子节点是否空，递归查询,找到返回
    	HeroNode resNode = null;//临时变量
    	if(this.left != null) {
    		resNode = this.left.postOrderSearch(no);
    	}
    	if(resNode != null) {//为真说明找到
    		return resNode;
    	}
    	//左子树未找到，递归右子树
    	if(this.right != null) {
    		resNode = this.right.postOrderSearch(no);
    	}
    	if(resNode != null) {//为真说明找到
    		return resNode;
    	}
    	System.out.println("进入后序查找~~");
    	//比较当前节点
    	if(this.no == no) {
    		return this;
    	}
    	return resNode;
    	
    }
}

 

 

shlr_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言：二叉树的各种操作（内附具体代码和思路）.docx
11-01
在IT领域，二叉树是一种基础且重要的数据结构，它被广泛应用于计算机科学的多个方面，如搜索、排序、编译器设计等。本篇文档主要介绍了如何在C语言...对于正在学习数据结构和C语言的学生来说，这是一个很好的实践案例。
已知二叉树的先序遍历序列为 ABCDEFGHIJ，中序遍历序列为 CBEFDGAHJI. （1）请画出这棵二叉树。（10分） (2)请写出该二叉树的后序遍历序列和层次遍历序列。
weixin_35755188的博客
12-19 1621
答复： 已知二叉树的先序遍历序列为 ABCDEFGHIJ，中序遍历序列为 CBEFDGAHJI，则可以通过这两个序列构建出如下的二叉树： A /\ B C / \ / \ D E F G / \ \ H I J 该二叉树的后序遍历序列为：DHIEFJBGCJA 该二叉树的层次遍历序列为：ABCDEFGHIJ ...
二叉树遍历（递归）
学习中
04-01 525
先序：A B D G H E C K F I J 打印自身 递归调用左子树 递归调用右子树 中序：G D H B E A K C I J F 递归调用左子树 先打印自身 递归调用右子树 （左边的全部打印完了，才打印自己，最后打印右边的） 后序：G H D E B K J I F C A 递归调用左子树 递归调用右子树 打印自身 （左边右边都打印完了，才打印自己） ...
常见二叉树及例题汇总
kyle的博客
05-29 3988
常见二叉树及例题汇总（更新中）
二叉树经典例题
种一棵树最好的时间是十年前，其次是现在。
10-18 719
二叉树： static class Node { private int data; private Node left; private Node right; public Node() { } public Node(int data) { this.da...
二叉树举例
liuchang_lc的博客
06-19 2922
二叉树与图举例说明 二叉树的定义，构造与遍历 树 是n(n>=0)个节点的 有限集 ，且这些节点 满足 如下关系: (1)有且仅有一个节点没有父结点，该节点称为树的 根 。 (2)除根外，其余的每个节点都有且仅有一个 父结点 。 (3)树中的每一个节点都构成一个 以它为根 的树。 二叉树 在满足树的条件时，满足如下条件: 每个节点最多有 两个孩子 (子树)，这两个子树有 左右之分 ，次序不可...
二叉树案例
03-29
一个二叉树的使用案例，包含了二叉树的创建 遍历 删除等操作。
python二叉树的实现实例
12-24
树的定义树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为结点）按...树的递归定义如下：（1）至少有一个结点（称为根）（2）其它是互不相交的子树二叉树：　二叉树是由n（n≥0）个结点组成的有限
平衡二叉树的实现实例
09-04
平衡二叉树是一种特殊的二叉树结构，它的特点是任何节点的两个子树的高度差不超过1，这确保了在平衡二叉树中查找、插入和删除操作的时间复杂度为O(log n)。平衡二叉树的主要类型包括AVL树和红黑树等。 在这个实现...
使用C语言求二叉树结点的最低公共祖先的方法
09-03
在二叉树中，最低公共祖先（Lowest Common Ancestor, LCA）是指在树中同时是两个给定节点的最近的共同祖先。本篇主要介绍如何使用C语言求解二叉树节点的最低公共祖先，并结合ACM的练习题目进行深入解析。 首先，...
二叉树实例
ay_一起沉默 的博客
08-27 4292
二叉树： 二叉树性质： 1.第i层的节点总数最多有2i-1个结点 2.深度额我k的二叉树最多有2k-1个结点，最少有k个结点 3.二叉树，如果其叶结点为n0，而度为2的结点总数为n2，则n0=n2+1 4.有n个结点的完全二叉树的深度k为：k=[log2n]+1 5.有n个结点的完全二叉树各结点如果用顺序表存储，对任意结点i，有如下关系： 如果
二叉树（上）
EUEH的博客
03-31 218
扫码关注公众号，获取更多内容 目录 一、什么是树？ 二、二叉树 三、二叉树的遍历 一、什么是树？ 我们先看下图的例子，这些“树”都有什么特征？ “树”这种数据结构很像真实生活中的“树”，这里面每个元素我们叫做“节点”。 比如下面这幅图，A节点叫做B节点的父节点，B节点是A节点的子节点。B,、C、D这三个节点的父节点是同一个节点，它们之间互称为兄弟节点。没有父节点的节点叫做根节点，下图中E就是根节点。没有子节点的节点叫做叶子节点或者叶节点，比如下图中的G、H、I、J、K、L，他们都是叶
二叉树例题剖析
andy dennis的博客
04-14 717
三种遍历递归实现 前序遍历 为了大家方便看，我先把代码贴上，再贴上树的形状图。 #include <iostream> using namespace std; int a[] = {1, 2, 3, 4, 5, 6}; void preVis(int cur, int n) { if (cur >= n) return; cout << cur << " "; preVis(2 * cur + 1, n); preVis(2 * cur + 2, n
关于二叉树的几个经典例题详解
Mr_fengzi的博客
07-13 1万+
1.某二叉树的前序序列和后序序列正好相反，则该二叉树一定是( )的二叉树。 A.空或只有一个结点 B.高度等于其结点数 C.任一结点无左孩子 D.任一结点无右孩子 正确答案：B 详解： 一棵具有N个结点的二叉树的前序序列和后序序列正好相反，则该二叉树一定满足该二叉树只有左子树或只有右子树，即该二叉树一定是一条链（二叉树的高度为N，高度等于结点数）。 ...
算法 二叉树简单案例
初心魏的博客
08-16 516
1.1 层次遍历树 思路： 使用队列 将树的根节点放入队列中 出队一个节点，将该节点的左右子节点放入队列中 直到队列为空 public class Tree_Order { public static void levelOrder(Node root) { Queue<Node> queue = new LinkedList(); qu...
数据结构——二叉树 （例题+代码）
weixin_48560325的博客
04-28 2899
1、先说什么是树？ 树是什么?简单来说，它是一种数据结构，就如单链表来说，每个节点都至少有这几个点；数值、后继节点指针、（有时候会有前驱结点指针）；对于树来说，也是每个节点按照不同于链表连接方式连接； 首先看一张图，也就是下面所要讲解所有代码都要用的例子； 这个图可以看出一个最基本的二叉树节点，至少含有；一个值、一个左孩子、一个右孩子；其他的树比如，T树、红黑树、B+树、B-树、等也就是对该节点的扩充，但是重要的是整体模型还是如此；对于树的来说，就是对树节点的连接不同； 2、对于一个二叉树书
二叉树的实际应用（应用场景）
热门推荐
心向暖的博客
03-20 3万+
哈夫曼编码，来源于哈夫曼树（给定n个权值作为n个叶子结点，构造一棵二叉树，若带权路径长度达到最小，称这样的二叉树为最优二叉树，也称为赫夫曼树(Huffman tree)。即带权路径长度最短的树），在数据压缩上有重要应用，提高了传输的有效性，详见《信息论与编码》。 海量数据并发查询，二叉树复杂度是O(K+LgN)。二叉排序树就既有链表的好处，也有数组的好处，在处理大批量的动态的数据是比较有用。 ...
数据结构~13.遍历二叉树的四个应用案例
qq_41424688的博客
08-08 3万+
数据结构学习~13.二叉树的深度 本文是上一篇文章的后续,详情点击该链接~
【数据结构与算法】——赫夫曼树
秋雨绵绵
06-08 1105
🎄：CSDN的小伙伴们大家好，今天跟大家分享一个二叉树的应用案例——赫夫曼树。如果这篇文章对你有用，麻烦给我点个小赞以示鼓励吧🎄
mysql用二叉树查询数据案例
最新发布
03-24
下面是一个简单的MySQL二叉树查询数据的案例： 首先，我们需要创建一个表来存储数据： CREATE TABLE `test` ( `id` int(11) NOT NULL AUTO_INCREMENT, `name` varchar(50) NOT NULL, `age` int(11) NOT NULL, ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值