二叉树的java实现，超级简单讲解版

最新推荐文章于 2024-09-19 16:35:54 发布
最新推荐文章于 2024-09-19 16:35:54 发布
阅读量277 收藏 1
点赞数
分类专栏： java 文章标签： java 面试 经验分享 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64374605/article/details/122051592
版权

二叉树的基本定义

简而言之：二叉树就是度不能超过2的树（每个树只能有两个节点）

满二叉树：

一个二叉树，如果每一个层的结点树达到最大值，则在这个树就是满二叉树

完全二叉树：

叶结点只能出现在最下层和次下层，并且最下面那一层的结点都集中在该层最左边的若干位置的二叉树

二叉查找树：

二叉查找树是一种特殊的二叉树，相对较小的值保存在左结点中，较大的值保存在右结点中。
根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们设计一个结点来描述结点这个事务。

首先我们先想着实现二叉树需要一些什么参数？

    private static class Node{
        public Node left;
        public Node right;
        public Integer key;
        public String value;

        public Node(Node left, Node right, Integer key, String value) {
            this.left = left;
            this.right = right;
            this.key = key;
            this.value = value;
        }
    }

在上面我们定义了left，right，key，value四个参数，并且定义了这个类的构造方法

我们看插入方法put思想：

  1. 如果当树中没有任何一个结点，则直接把新结点当根结点使用
  2. 如果当前树不为空，就从根结点开始
    2-1：如果要查询的key，小于当前结点的key，则继续查找当前结点的左子结点2-2：如果新结点的key大于当前结点的key，则继续找当前结点的右子结点2-3：如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值就好

那么我们要怎么实现呢？

    //向树中插入一个键值对
    public void put(Integer key,String value){
        root=put(root,key,value);
    }
    //给指定的数x添加一个键,添加一个键值对，并返回添加后的新数
    private Node put(Node tree,Integer key,String value){
        if(tree==null){
            //个数加1
            n++;
            //直接把新结点当成根结点使用
            return new Node(null,null,key,value);
        }
        //比较key,如果新结点大于当前结点的key，继续寻找当前结点的右子结点
        if(key > tree.key){
            tree.right=put(tree.right,key,value);
        }else if(key<tree.key){
            //新结点的key小于当前结点的key,继续找当前结点的左子结点
            tree.left=put(tree.left,key,value);
        }else{
            //新结点的key等于当前结点的key
            tree.value=value;
        }
        return tree;
    }

在上面的代码块中，我们定义了两个put方法，一个是给其他类操作的，一个是给自己类操作的，对于外部的用户来说，他只需要将键值对传递进来就好了，排序是我们程序员的事，所以，我们这里的put只有两个参数：

public void put(Integer key,String value)

然后我们通过这个put方法再去调用我们内部的put方法，在这个方法中，我们首先要把我们的根结点root传递进去，然后再将前端传给我们的key：value传递进去

private Node put(Node tree,Integer key,String value)

这样，我们就可以在这个put上进行我们一开始定义的开发流程了：

  1. 如果树中没有结点，就把当前插入的结点当成首节点使用：
        if(tree==null){
            //个数加1
            n++;
            //直接把新结点当成根结点使用
            return new Node(null,null,key,value);
        }
  1. 如果树不为空，就从根结点开始遍历，也就是root结点
    2-1. 如果要查询的key，小于当前结点的key，则继续查找当前结点的左子结点
        //比较key,如果新结点大于当前结点的key，继续寻找当前结点的右子结点
        if(key > tree.key){
            tree.right=put(tree.right,key,value);
        }

2-2. 如果新结点的key大于当前结点的key，则继续找当前结点的右子结点

else if(key<tree.key){
            //新结点的key小于当前结点的key,继续找当前结点的左子结点
            tree.left=put(tree.left,key,value);
        }

2-3：如果新结点的key等于当前结点的key，则树中已经存在这样的结点，替换该结点的value值就好

else{
            //新结点的key等于当前结点的key
            tree.value=value;
        }

现在put方法就执行完毕了，我们把一个前端传递过来的值放入了二叉树中.

上面我们已经实现了二叉树中的put方法，按照我的习惯的话呢接下来我们还是先讲思想，讲get方法和delete方法：

查询方法get实现思想：
从根结点开始：

  1. 如果要查询的key小于当前结点的key，则继续查找当前结点的左子结点
  2. 如果要查询的key大于当前结点的key，则继续找当前结点的右子结点
  3. 如果要查询的key等于当前结点的key，则树中返回当前结点的value

删除方法delete实现思想：

  1. 找到被删除结点
  2. 找到被删除结点右子树的最小结点
  3. 删除右子树中的最小结点
  4. 让被删除结点的左子树称为最小结点的左子树，让被删除结点的右子树称为最小结点的子树
  5. 让被删除节点的父结点指向最小结点

按照从简单到困难的准则，我们先从简单的开始，get方法相对于delete而言要简单一点，所以我们先实现get方法

    //从树中找到对应的值
    public String get(Integer key){
        return get(root,key);
    }
    private String get(Node tree,Integer key){
        if(root==null){
            return null;
        }
        //比较key,如果新结点大于当前结点的key，继续寻找当前结点的右子结点
        if(key > tree.key){
            
            return get(tree.right,key);
        }else if(key<tree.key){
            //比较key,如果新结点大于当前结点的key，继续寻找当前结点的左子结点
         
            return get(tree.left,key);
        }else{
            //要查找的key和当前结点的key相等，返回value
            return tree.value;
        }
    }

通过不停的递归调用get方法，我们就可以不断的查找树的左右结点，从而最终返回get到的结果值，这个非常简单，没什么好说的。

接下来比较重要的是delete方法：

    //从指定的树中，根据key删除键中的键值对
    public void delete(Integer key){

        root=delete(root,key);
    }
    private Node delete(Node tree,Integer key){
        if(tree==null){
            return null;
        }
        if(key > tree.key){
            tree.right=delete(tree.right,key);
        }else if(key<tree.key){
            tree.left=delete(tree.left,key);
        }else{
            //待删除的key等于当前结点的key，说明当前结点就是要删除的结点
            //1、如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if(tree.right==null){
                n--;
                return tree.left;
            }
            //2、如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if(tree.left==null){
                n--;
                return  tree.right;
            }
            //当前结点的左右子树都存在
            //找到右子树中的最小结点
            Node minNode=tree.right;
            //二叉查找树的左结点一定比右结点小
            if(minNode.left!=null){
                minNode=minNode.left;
            }
            //到这里就找到了当前结点右子树中最小的结点minNode
            //删除右子树中最小的结点
            Node node=tree.right;
            while (node.left!=null){
                if(node.left.left==null){
                    //说明N的左结点就是我们要找的最小结点
                    node.left=null;
                }else{
                    node=node.left;
                }
            }
            //到这里，最小结点已经被删除了
            //让被删除结点的左子树成为最小结点的左子树，让被删除结点的右子树，成为最小结点的右子树
            minNode.left=tree.left;
            minNode.right=tree.right;
            //让被删除结点的父结点指向最小结点
            tree=minNode;
            //个数减1
            n--;
        }
        return tree;
    }

上面的这段代码看着很长，且听我与你一一分解

首先我们通过public方法方便别的类调用，用户只需要传递key值进入我们的后台，我们就可以通过后台的查找方法来查找二叉树中的元素，然后对其进行删除。

这同样使用了递归的思想。通过不断的查找二叉树中的元素，找到要删除的那个数据。

        if(key > tree.key){
            tree.right=delete(tree.right,key);
        }else if(key<tree.key){
            tree.left=delete(tree.left,key);
        }else{
            //待删除的key等于当前结点的key，说明当前结点就是要删除的结点
            //1、如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if(tree.right==null){
                n--;
                return tree.left;
            }
            //2、如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if(tree.left==null){
                n--;
                return  tree.right;
            }
            //当前结点的左右子树都存在
            //找到右子树中的最小结点
            Node minNode=tree.right;
            //二叉查找树的左结点一定比右结点小
            if(minNode.left!=null){
                minNode=minNode.left;
            }
            //到这里就找到了当前结点右子树中最小的结点minNode
            //删除右子树中最小的结点
            Node node=tree.right;
            while (node.left!=null){
                if(node.left.left==null){
                    //说明N的左结点就是我们要找的最小结点
                    node.left=null;
                }else{
                    node=node.left;
                }
            }
            //到这里，最小结点已经被删除了
            //让被删除结点的左子树成为最小结点的左子树，让被删除结点的右子树，成为最小结点的右子树
            minNode.left=tree.left;
            minNode.right=tree.right;
            //让被删除结点的父结点指向最小结点
            tree=minNode;
            //个数减1
            n--;
        }

如果当前递归到的这个结点的元素值小于我们用户传递进来的key的话我们将其往左进行递归

        if(key > tree.key){
            tree.right=delete(tree.right,key);
        }

如果大于的话我们就往右进行递归

else if(key<tree.key){
            tree.left=delete(tree.left,key);
        }

如果说用户传递过来的key与当前结点的key值相等的话，那么说明当前的这个结点就是我们要删除的这个结点

else{
            //待删除的key等于当前结点的key，说明当前结点就是要删除的结点
            //1、如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if(tree.right==null){
                n--;
                return tree.left;
            }
            //2、如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if(tree.left==null){
                n--;
                return  tree.right;
            }
            //当前结点的左右子树都存在
            //找到右子树中的最小结点
            Node minNode=tree.right;
            //二叉查找树的左结点一定比右结点小
            if(minNode.left!=null){
                minNode=minNode.left;
            }
            //到这里就找到了当前结点右子树中最小的结点minNode
            //删除右子树中最小的结点
            Node node=tree.right;
            while (node.left!=null){
                if(node.left.left==null){
                    //说明N的左结点就是我们要找的最小结点
                    node.left=null;
                }else{
                    node=node.left;
                }
            }
            //到这里，最小结点已经被删除了
            //让被删除结点的左子树成为最小结点的左子树，让被删除结点的右子树，成为最小结点的右子树
            minNode.left=tree.left;
            minNode.right=tree.right;
            //让被删除结点的父结点指向最小结点
            tree=minNode;
            //个数减1
            n--;
        }
        return tree;
    }

现在又要研究二叉树中的删除方法中结点的性质了，我们既然要把这个元素进行删除操作的话，那么是不是，我们就要将他的子结点的层级往上提升一级，那么我们接着研究：

            //待删除的key等于当前结点的key，说明当前结点就是要删除的结点
            //1、如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if(tree.right==null){
                n--;
                return tree.left;
            }
            //2、如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if(tree.left==null){
                n--;
                return  tree.right;
            }

如果当前结点的右子树不存在，那么我们就把该结点的左子树给他提上去
如果当前结点的左子树不存在，那么我们就把他的右子树提上去

如果说当前结点的左右子树都存在的话，那么就有点小麻烦了，那么我们就要从要被删除的这个结点的右子树中找到他的最小元素，然后把他的最小元素给他提上去。

            //到这里就找到了当前结点右子树中最小的结点minNode
            //删除右子树中最小的结点
            Node node=tree.right;
            while (node.left!=null){
                if(node.left.left==null){
                    //说明N的左结点就是我们要找的最小结点
                    node.left=null;
                }else{
                    node=node.left;
                }
            }
            //到这里，最小结点已经被删除了
            //让被删除结点的左子树成为最小结点的左子树，让被删除结点的右子树，成为最小结点的右子树
            minNode.left=tree.left;
            minNode.right=tree.right;
            //让被删除结点的父结点指向最小结点
            tree=minNode;
            //个数减1
            n--;
        }

最后在我们所有操作都已经执行完毕之后，我们只要返回这个改变之后的tree就好了

好了，现在我们创建一个外部类Test1来验证此程序的正确性

class Test1{
    public static void main(String[] args) {
        BinaryTree tree=new BinaryTree();
        tree.put(8,"鸡霸");
        tree.put(7,"田七");
        tree.put(9,"吴久");
        tree.put(3,"张三");
        tree.put(6,"陆远");
        System.out.println(tree.get(7));
        tree.delete(6);
        tree.delete(9);
        tree.delete(3);
        System.out.println(tree.size());
    }
}

然后我放出全部代码方便大家实验：

package com.gm.tree;

public class BinaryTree {
    //记录一个根结点
    private Node root;
    //记录树中的元素个数
    private int n;

    public BinaryTree() {
    }
    //向树中插入一个键值对
    public void put(Integer key,String value){
        root=put(root,key,value);
    }
    //给指定的数x添加一个键,添加一个键值对，并返回添加后的新数
    private Node put(Node tree,Integer key,String value){
        if(tree==null){
            //个数加1
            n++;
            //直接把新结点当成根结点使用
            return new Node(null,null,key,value);
        }
        //比较key,如果新结点大于当前结点的key，继续寻找当前结点的右子结点
        if(key > tree.key){
            tree.right=put(tree.right,key,value);
        }else if(key<tree.key){
            //新结点的key小于当前结点的key,继续找当前结点的左子结点
            tree.left=put(tree.left,key,value);
        }else{
            //新结点的key等于当前结点的key
            tree.value=value;
        }
        return tree;
    }
    //从树中找到对应的值
    public String get(Integer key){
        return get(root,key);
    }
    private String get(Node tree,Integer key){
        if(root==null){
            return null;
        }
        //比较key,如果新结点大于当前结点的key，继续寻找当前结点的右子结点
        if(key > tree.key){
            return get(tree.right,key);
        }else if(key<tree.key){
            //比较key,如果新结点大于当前结点的key，继续寻找当前结点的左子结点
            return get(tree.left,key);
        }else{
            //要查找的key和当前结点的key相等，返回value
            return tree.value;
        }
    }
    //从指定的树中，根据key删除键中的键值对
    public void delete(Integer key){

        root=delete(root,key);
    }
    private Node delete(Node tree,Integer key){
        if(tree==null){
            return null;
        }
        if(key > tree.key){
            tree.right=delete(tree.right,key);
        }else if(key<tree.key){
            tree.left=delete(tree.left,key);
        }else{
            //待删除的key等于当前结点的key，说明当前结点就是要删除的结点
            //1、如果当前结点的右子树不存在，则直接返回当前结点的左子结点
            if(tree.right==null){
                n--;
                return tree.left;
            }
            //2、如果当前结点的左子树不存在，则直接返回当前结点的右子结点
            if(tree.left==null){
                n--;
                return  tree.right;
            }
            //当前结点的左右子树都存在
            //找到右子树中的最小结点
            Node minNode=tree.right;
            //二叉查找树的左结点一定比右结点小
            if(minNode.left!=null){
                minNode=minNode.left;
            }
            //到这里就找到了当前结点右子树中最小的结点minNode
            //删除右子树中最小的结点
            Node node=tree.right;
            while (node.left!=null){
                if(node.left.left==null){
                    //说明N的左结点就是我们要找的最小结点
                    node.left=null;
                }else{
                    node=node.left;
                }
            }
            //到这里，最小结点已经被删除了
            //让被删除结点的左子树成为最小结点的左子树，让被删除结点的右子树，成为最小结点的右子树
            minNode.left=tree.left;
            minNode.right=tree.right;
            //让被删除结点的父结点指向最小结点
            tree=minNode;
            //个数减1
            n--;
        }
        return tree;
    }
    public int size(){
        return n;
    }
    private static class Node{
        public Node left;
        public Node right;
        public Integer key;
        public String value;

        public Node(Node left, Node right, Integer key, String value) {
            this.left = left;
            this.right = right;
            this.key = key;
            this.value = value;
        }
    }
}
class Test1{
    public static void main(String[] args) {
        BinaryTree tree=new BinaryTree();
        tree.put(8,"雷霸天");
        tree.put(7,"田七");
        tree.put(9,"吴久");
        tree.put(3,"张三");
        tree.put(6,"陆远");
        System.out.println(tree.get(7));
        tree.delete(6);
        tree.delete(9);
        tree.delete(3);
        System.out.println(tree.size());
    }
}
Java雨孟
关注
专栏目录
java实现区块链p2p网络_详解区块链P2P网络
weixin_36378951的博客
02-27 1085
根据前一篇文章《从微观到宏观理解区块链》我们已经了解到，微观上，区块链本质就是一种不可篡改且可追踪溯源的哈希链条；宏观上，还具备了另外三个基本特征：分布式存储、P2P 网络和共识机制。分布式存储无非就是网络上大部分节点都保存了整条区块链，这容易理解也不复杂，所以就没必要再展开细讲了。但区块链的 P2P 网络和共识机制相对则复杂得多，因此我将用两篇文章分别展开讲讲这两部分内容，本篇文章就先来了解区块...
二叉树的java实现
07-14
二叉树的java实现
二叉树的java实现 超级简单讲解版！
title_martin的博客
11-23 1561
二叉树的基本定义 简而言之：二叉树就是度不能超过2的树（每个树只能有两个节点） 满二叉树： 一个二叉树，如果每一个层的结点树达到最大值，则在这个树就是满二叉树 完全二叉树： 叶结点只能出现在最下层和次下层，并且最下面那一层的结点都集中在该层最左边的若干位置的二叉树 二叉查找树 二叉查找树是一种特殊的二叉树，相对较小的值保存在左结点中，较大的值保存在右结点中。 根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们设计一个结点来描述结点这个事务。 ...
java实现二叉树
最新发布
2401_84436253的博客
09-19 1743
从上面的图可以看出来树是这个整体，在没有添加任何节点的时候这个根节点就是这个树，遍历树只需要知道树的根节点就可以知道树的任何一个节点。//树的根节点public class TNode { //定义树的节点，节点中含有的数据public TNode(int data) { //创建节点的方法此时还需要对树的根节点进行初始化。
Java二叉树的实现
四川兔兔的博客
12-30 421
结点： 我们主要来看看二叉树的遍历，求树的高度，结点总数。这三个方法实现很简单，就是递归。 思想： 二叉树的遍历：先序遍历，中序遍历，后序遍历。框架一样，只不过输出的位置有差异 //先序遍历 public void preOrderVisit() { System.out.print("" + value + " "); if(leftChild != null) { leftChild.preOrderVisit(); }// Of if if(rightChild !
二叉树（Java实现）
热门推荐
JiaXingNashishua的博客
05-22 1万+
声明：本文部分文章取自于 Java中关于二叉树详解_来学习的小张的博客-CSDN博客_java 二叉树原理 更多关于二叉树详情可以点击上面链接 一：树形结构 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点； 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、......、Tm，其中每一个
二叉树JAVA实现
YEN_CSDN的博客
10-21 1214
二叉树是一种常用的数据结构，每一个元素最多有两棵子树。在二叉搜索树中，“小于等于”指定节点元素的元素被放到左子树，“大于”指定节点元素的元素放到右子树。二叉树的定义：package tree;/** * DateTime: 2016/10/21 16:08 * 功能：一棵树的定义 * 思路： */ public class SimpleTree<T extends Comparable>
Java工程师成神之路 | 2022正式版
m0_67698950的博客
06-15 1298
面向对象什么是面向对象面向对象与面向过程面向对象的三大基本特征面向对象的五大基本原则封装、继承、多态什么是多态方法重写与重载Java的继承与实现Java的继承与组合构造函数与默认构造函数类变量、成员变量和局部变量成员变量和方法作用域平台无关性Java如何实现的平台无关性的JVM还支持哪些语言值传递值传递、引用传递为什么说Java中只有值传递小伙伴们有兴趣想了解内容和更多相关学习资料的请点赞收藏+评论转发+关注我，后面会有很多干货。我有一些面试题、架构、设计类资料可以说是程序员面试必备！所有资料都整理到网盘了
Java基础大纲
haifeng的博客
11-07 1045
Java基础梳理，大致内容，常常回顾，避免忘记
Java知识点概览
qq_48403611的博客
08-03 3481
java后端开发常见面试题总结
java 二叉树实现
10-12
java二叉树实现 （简单实现，入门用） /**创建二叉树*/ public BinaryTree createTree(String treeStr); /**寻找结点*/ public BinaryTree findNode(BinaryTree tree ,char sign); /**找所给结点的左子树*/ public BinaryTree lChildren(BinaryTree node); /**找所给结点的右子树*/ public BinaryTree rChildren(BinaryTree node); /**求二叉树高度*/ public int treeDepth(BinaryTree tree); /**输出树（括号表示法）*/ public void disPlayTree(BinaryTree tree);
java二叉树实现
sj_1993的博客
05-05 486
二叉树的原理分析 树是一种重要的非线性数据结构，直观地看，它是数据元素(在树中称为结点)按分支关系组织起来的结构。二叉树是每个结点最多有两个子树的有序树。通常子树被称为“左子树”和“右子树”。 二叉树算法排序规则： 选择第一个元素作为根节点 之后如果元素大于根节点放在右子树，如果元素小于根节点放在左子树 最后按照中序遍历的方式进行输出，则可以得到排序的结果(左->根-...
Java实现二叉树
南瓜籽_的博客
11-12 423
Java实现二叉树
Java实现二叉树创建与遍历操作详解
资源摘要信息:"该资源是一个Java项目，主要包含以下几个部分：src目录包含了所有源代码文件，这些文件定义了二叉树的数据结构以及实现了三种遍历算法；pom.xml文件是Maven项目对象模型文件，用于定义项目依赖以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值