java实现二叉树数据结构

最新推荐文章于 2024-09-18 22:23:06 发布
最新推荐文章于 2024-09-18 22:23:06 发布
阅读量1.3k 收藏 2
点赞数
分类专栏： 数据结构 文章标签： 二叉树 java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/HeadingAlong/article/details/54800355
版权

上篇博客对链表的结构进行了代码实现，今天让我用java代码带大家了解二叉树的实现原理。
首先大家对二叉树的结构都应该了解，二叉树是由节点构成的，每个节点最多有两个字节点，称为左子节点和右子节点，还有parent父节点。
今天的demo注释写的非常清楚，希望有兴趣的可以跟着注释来看，如果有不懂 的可以在下方评论，我会及时回复。

节点的定义

class Node{
        private T date;//节点数据
        private Node parent;//父节点
        private Node left;//左子节点
        private Node right;//右子节点

        public Node(T date){
            this.date = date;
        }
    }

二叉树的属性

    private Node root;//根节点

数据的添加

/**
     * 添加数据
     * @param date
     * @return
     */
    public boolean add(T date){
        boolean flag = false;
        //判断数据是否已经存在
        if(!exist(date)){//数据不存在，可以添加
            Node newNode = new Node(date);//构建新节点
            //判断是否有数据
            if(root==null){
                root = newNode;//将新建节点作为根节点
            }else{
                //找到父节点
                Node parent = findParent(date);
                if(parent!=null){
                    if(parent.date.compareTo(date)>0){
                        parent.left =  newNode;//父节点的左节点指向新建节点
                    }else{
                        parent.right = newNode;//父节点的右节点指向新建节点
                    }
                    newNode.parent = parent;//新建节点的parent节点指向父节点
                }
            }
            flag = true;

        }else{
            return flag;
        }
        return flag;
    }

删除某个数据

该部分逻辑比较复杂，但我每一种情况都分析到了，按主次情况已经一一列出。

/**
     * 删除数据
     * @param date
     * @return
     */
    public boolean remove(T date){
        boolean flag = false;
        Node node = getNode(date);
        if(node!=null){
            if(node==root){//1.删除的是根节点
                if(node.right==null && node.left==null){//1.1无左右子节点
                    root = null;
                }
                else if(node.left==null && node.right!=null){//1.2无左节点
                    node.right.parent=null;//将要删节点的右侧节点的parent置为null
                    root = node.right;//将要删节点的右节点作为根节点
                }else if(node.left!=null && node.right==null){//1.3无右节点
                    node.left.parent = null;//将要删节点的左侧节点的parent置为null
                    root = node.left;//将要删节点的左节点作为根节点
                }else{//1.4有左右节点
                    Node left = split(date);//分割节点，得到要删节点的左节点，
                    root = left;//将left节点作为根节点
                    left.parent = null;//将left的parent置为null
                }
            }else{//2.删除的是非根节点
                if(node.right==null && node.left==null){//2.1无左右子节点
                    if(node.date.compareTo(node.parent.date)<0){//该节点是父节点的左子节点
                        node.parent.left = null;//将父节点的left置为null
                    }else{//该节点的父节点的右字节点
                        node.parent.right = null;//将父节点的right置为null
                    }
                }else if(node.left==null && node.right!=null){//2.2无左节点
                    node.right.parent = node.parent;//将该节点的右节点的parent指向该节点的parent
                    node.parent.right = node.right;//将该节点的parent节点的right指向该节点的right节点
                }else if(node.left!=null && node.right==null){//2.3无右节点
                    node.parent.right = node.left;//将该节点的父节点的right指向该节点的left节点
                    node.left.parent = node.parent;//将该节点得left节点的parent指向该节点的parent节点
                }else{//2.4有左右节点
                    Node left = split(date);//将要删的节点分割，返回该节点的左节点
                    node.parent.left = node.left;//将要删节点的父节点的left指向该节点的左节点，
                    left.parent = node.parent;//将分割后的左节点的parent指向要删节点的父节点
                }
            }
            flag = true;
        }
        return flag;
    }

遍历

public void print() {
        see(root);
    }
    /**
     * 打印节点数据
     * @param root2
     */
    private void see(Node node) {//中序打印
        if(node!=null){
            see(node.left);
            System.out.println(node.date);
            see(node.right);
        }
    }

用到的几个辅助方法

  • split(T date)—>
    将从指定节点切割，并将被切掉节点的右子节点拼接在左节点正确的位置，将剩余的漏出来的左节点返回。
/**
     * 分割要删数据的节点，默认左节点作为父节点，并将右节点指向左节点的最大节点的right
     * @param date
     * @return
     */
    private Node split(T date) {
        //找到节点
        Node node = getNode(date);
        //找到左节点的最大数节点
        Node  big = getBig(node.left);
        //将要分割节点的右节点的parent指向big
        node.right.parent = big;
        //将big的右节点指向node的右节点
        big.right = node.right;
        return node.left;
    }
  • getBig（Node node）—>
    从指定节点向下寻找，找到数据值最大的节点并返回
/**
     * 从node开始找最大的节点
     * @param left
     * @return
     */
    private Node getBig(Node node) {
        Node temp = node;
        while(temp!=null){
            if(temp.right!=null){
                temp = temp.right;
            }else{
                return temp;
            }
        }
        return null;
    }
  • findParent(T date)—–>
    找到新建节点即将插入树中的它的父节点。
/**
     * 找到父节点
     * @param date
     * @return
     */
    private Node findParent(T date) {
        Node temp = root;//从根节点开始遍历
        Node prev = temp;
        while(temp!=null){//跳出循环时，temp为null，prev记录上一个节点
            prev = temp;//用prev记录上一个节点
            if(temp.date.compareTo(date)<0){//从右节点寻找
                temp = temp.right;
            }else{//从左节点开始遍历
                temp = temp.left;
            }
        }
        return prev;
    }
  • exist(T date)—>
    判断树中是否存在该数据
/**
     * 判断数据存在与否
     * @param date
     * @return
     */
    private boolean exist(T date) {
        boolean flag = false;
        Node temp = root;//从根节点开始遍历
        while(temp!=null){
            if(temp.date.compareTo(date)==0){//数据已经存在
                flag = true;
                break;
            }else{
                if(temp.date.compareTo(date)<0){//从右节点寻找
                    temp = temp.right;
                }else{//从左节点开始遍历
                    temp = temp.left;
                }
            }
        }
        return flag;
    }
  • getNode(T date)—>
    在树中找到某个数据对应的节点
/**
     * 获得节点
     * @param date
     * @return
     */
    private Node getNode(T date) {
        Node temp = root;//从根节点开始遍历
        while(temp!=null){
            if(temp.date.compareTo(date)==0){//数据已经存在
                return temp;
            }else{
                if(temp.date.compareTo(date)<0){//从右节点寻找
                    temp = temp.right;
                }else{//从左节点开始遍历
                    temp = temp.left;
                }
            }
        }
        return null;
    }

因为我不知道如何上传非图片的文件，所以只能把代码帖在最下面了。

package com.it;
/**
 * 
 * 该类实现有序二叉树的数据存储结构
 * @author Administrator
 *
 */
public class BinaryTree<T extends Comparable<T>> {
    class Node{
        private T date;//节点数据
        private Node parent;//父节点
        private Node left;//左子节点
        private Node right;//右子节点

        public Node(T date){
            this.date = date;
        }
    }
    private Node root;//根节点
    /**
     * 添加数据
     * @param date
     * @return
     */
    public boolean add(T date){
        boolean flag = false;
        //判断数据是否已经存在
        if(!exist(date)){//数据不存在，可以添加
            Node newNode = new Node(date);//构建新节点
            //判断是否有数据
            if(root==null){
                root = newNode;//将新建节点作为根节点
            }else{
                //找到父节点
                Node parent = findParent(date);
                if(parent!=null){
                    if(parent.date.compareTo(date)>0){
                        parent.left =  newNode;//父节点的左节点指向新建节点
                    }else{
                        parent.right = newNode;//父节点的右节点指向新建节点
                    }
                    newNode.parent = parent;//新建节点的parent节点指向父节点
                }
            }
            flag = true;

        }else{
            return flag;
        }
        return flag;
    }
    /**
     * 删除数据
     * @param date
     * @return
     */
    public boolean remove(T date){
        boolean flag = false;
        Node node = getNode(date);
        if(node!=null){
            if(node==root){//1.删除的是根节点
                if(node.right==null && node.left==null){//1.1无左右子节点
                    root = null;
                }
                else if(node.left==null && node.right!=null){//1.2无左节点
                    node.right.parent=null;//将要删节点的右侧节点的parent置为null
                    root = node.right;//将要删节点的右节点作为根节点
                }else if(node.left!=null && node.right==null){//1.3无右节点
                    node.left.parent = null;//将要删节点的左侧节点的parent置为null
                    root = node.left;//将要删节点的左节点作为根节点
                }else{//1.4有左右节点
                    Node left = split(date);//分割节点，得到要删节点的左节点，
                    root = left;//将left节点作为根节点
                    left.parent = null;//将left的parent置为null
                }
            }else{//2.删除的是非根节点
                if(node.right==null && node.left==null){//2.1无左右子节点
                    if(node.date.compareTo(node.parent.date)<0){//该节点是父节点的左子节点
                        node.parent.left = null;//将父节点的left置为null
                    }else{//该节点的父节点的右字节点
                        node.parent.right = null;//将父节点的right置为null
                    }
                }else if(node.left==null && node.right!=null){//2.2无左节点
                    node.right.parent = node.parent;//将该节点的右节点的parent指向该节点的parent
                    node.parent.right = node.right;//将该节点的parent节点的right指向该节点的right节点
                }else if(node.left!=null && node.right==null){//2.3无右节点
                    node.parent.right = node.left;//将该节点的父节点的right指向该节点的left节点
                    node.left.parent = node.parent;//将该节点得left节点的parent指向该节点的parent节点
                }else{//2.4有左右节点
                    Node left = split(date);//将要删的节点分割，返回该节点的左节点
                    node.parent.left = node.left;//将要删节点的父节点的left指向该节点的左节点，
                    left.parent = node.parent;//将分割后的左节点的parent指向要删节点的父节点
                }
            }
            flag = true;
        }
        return flag;

    }
    /**
     * 分割要删数据的节点，默认左节点作为父节点，并将右节点指向左节点的最大节点的right
     * @param date
     * @return
     */
    private Node split(T date) {
        //找到节点
        Node node = getNode(date);
        //找到左节点的最大数节点
        Node  big = getBig(node.left);
        //将要分割节点的右节点的parent指向big
        node.right.parent = big;
        //将big的右节点指向node的右节点
        big.right = node.right;
        return node.left;
    }
    /**
     * 从node开始找最大的节点
     * @param left
     * @return
     */
    private Node getBig(Node node) {
        Node temp = node;
        while(temp!=null){
            if(temp.right!=null){
                temp = temp.right;
            }else{
                return temp;
            }
        }
        return null;
    }
    /**
     * 找到父节点
     * @param date
     * @return
     */
    private Node findParent(T date) {
        Node temp = root;//从根节点开始遍历
        Node prev = temp;
        while(temp!=null){//跳出循环时，temp为null，prev记录上一个节点
            prev = temp;//用prev记录上一个节点
            if(temp.date.compareTo(date)<0){//从右节点寻找
                temp = temp.right;
            }else{//从左节点开始遍历
                temp = temp.left;
            }
        }
        return prev;
    }
    /**
     * 判断数据存在与否
     * @param date
     * @return
     */
    private boolean exist(T date) {
        boolean flag = false;
        Node temp = root;//从根节点开始遍历
        while(temp!=null){
            if(temp.date.compareTo(date)==0){//数据已经存在
                flag = true;
                break;
            }else{
                if(temp.date.compareTo(date)<0){//从右节点寻找
                    temp = temp.right;
                }else{//从左节点开始遍历
                    temp = temp.left;
                }
            }
        }
        return flag;
    }
    /**
     * 获得节点
     * @param date
     * @return
     */
    private Node getNode(T date) {
        Node temp = root;//从根节点开始遍历
        while(temp!=null){
            if(temp.date.compareTo(date)==0){//数据已经存在
                return temp;
            }else{
                if(temp.date.compareTo(date)<0){//从右节点寻找
                    temp = temp.right;
                }else{//从左节点开始遍历
                    temp = temp.left;
                }
            }
        }
        return null;
    }

    public void print() {
        see(root);
    }
    /**
     * 打印节点数据
     * @param root2
     */
    private void see(Node node) {//中序打印
        if(node!=null){
            see(node.left);
            System.out.println(node.date);
            see(node.right);
        }
    }

}
【Java数据结构】二叉树的实现
adminuser_H2的博客
04-28 247
1、二叉树基本概念：二叉树是每个节点最多有两个子树的有序树。通常子树的根被称作“左子树”和“右子树”。 2、二叉树的单个结点：左子树、右子树、值。 class TreeNode {//一个结点的构造方法 public char val; public TreeNode left; public TreeNode right; public TreeNode (char val) { this.val = val; } } 3、二叉树：为了方便调
【数据结构 Java 版】二叉树的实现（超多图、超详解）
2401_84408814的博客
04-20 1742
外链图片转存中…(img-Tagg2LA9-1713549071340)][外链图片转存中…(img-8RPdBjtL-1713549071343)][外链图片转存中…(img-0cwFlrsL-1713549071345)]
数据结构二叉树专题java代码实现
04-02
数据结构二叉树专题java代码实现
java的数据结构二叉树_java 数据结构二叉树的实现代码
weixin_42511491的博客
02-15 162
1。 二叉树接口public interface BinaryTreeInterface {public T getRootData();public int getHeight();public int getNumberOfRoot();public void clear();public void setTree(T rootData); // 用rootData设置树public void...
【数据结构】二叉树
最新发布
DerrictC的博客
09-18 1097
该算法从堆的根节点开始，通过比较和交换节点值，将根节点调整到其在堆中的正确位置，以确保堆的每个父节点的值都大于或等于其子节点的值（在最大堆中），或者小于或等于其子节点的值（在最小堆中）。我们常见的二叉树的结构叫逻辑结构如下图1，这是我们自己想象出来的二叉树的样子，但实际上二叉树并不是就像图中所示的那样，二叉树真正的结构，也叫物理结构，是像数组一样每个数据一行排开，如图2，图2所示及是实实在在。也就是说，如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。如果二叉树为空，则退出；
使用java实现二叉树结构
qq_50852965的博客
09-18 184
实现二叉树的添加数据，遍历输出 代码如下： /** * 节点 * @author Hzy * */ class Node{ //左子节点 Node leftNode; //右子节点 Node rightNode; //中值 Object value; /** * 添加节点的方法 */ public void add(Object v) { //如果当前添加值的节点没有值，将v赋值给value if (this.value == null) { this.va
二叉树 数据结构
05-10 396
实验四 二叉树子系统 1.实验目的 （1）掌握二叉树的特点及其存储方式。 （2）掌握二叉树的创建和显示方法。 （3）复习二叉树遍历的概念，掌握二叉树遍历的基本方法。 2．实验内容 （1）按屏幕提示用前序方法建立一棵二叉树。 （2）编写各个函数：前序遍历、中序遍历、后序遍历、层次遍历、求二叉树的叶子结点数、求二叉树的总结点数、求二叉树的深度。 （3）设计一个选择式菜单，...
Java实现二叉树数据结构
qq_42843172的博客
08-10 113
Java实现二叉树数据结构 https://blog.csdn.net/tjh625/article/details/86561969
广工数据结构课程设计大作业-平衡二叉树-Java实现（数据结构期末）
11-13
在本项目中，我们主要探讨的是数据结构领域中的一个重要概念——平衡二叉树，并通过Java编程语言进行实现。平衡二叉树是一种特殊的二叉搜索树，它的左右子树的高度差不超过1，从而保证了树的平衡性，进一步提高了...
JAVA实现数据结构：二叉树
TmikuJ的学习笔记
01-22 221
参考书籍：《大话数据结构》 树 树（tree）是包含n（n>=0）个结点的有穷集，其中： （1）每个元素称为结点（node）； （2）有一个特定的结点被称为根结点或树根（root）。 （3）除根结点之外的其余数据元素被分为m（m≥0）个互不相交的集合T1，T2，……Tm-1，其中每一个集合Ti（1<=i<=m）本身也是一棵树，被称作原树的子树（subtree）。 结点 结点...
二叉树数据结构
weixin_30268071的博客
01-22 106
1. Js二叉树数据的创建 function Node(data,left,right) { this.data = data; this.left = left; this.right = right; } //定义插入对象 function BST(){ ...
数据结构的Java实现——二叉树
山顶冻人的专栏
03-30 1万+
二叉树的二叉链表实现、先序、中序、后序遍历实现
java数据结构之二叉树实现
java编程学习_java基础教程_booyzhang的博客
05-08 251
树是一种重要的非线性数据结构，直观地看，它是数据元素（在树中称为节点）按分支关系组织起来的结构。二叉树（Binary Tree）是每个节点最多有两个子树的有序树。通常子树被称作“左子树”和“右子树”。 二叉树算法的排序规则： 1、选择第一个元素作为根节点 2、之后如果元素大于根节点放在右子树，如果元素小于根节点，则放在左子树 3、最好按照中序遍历的方式进行输出，则可以得到排序的结果（左→根→右） 如：1、2、3、4、5、6、7、8、9、10 实例代码： 主类： package com.booy1; pu
java实现设计一个二叉树类的结构
qq_56467927的博客
11-01 721
二叉树是每个节点最多有两个子树的数结构，被常用语实现二茬查找数和二叉堆,使用java可实现设计二叉树的结构 package treeTest; import java.util.ArrayList; import java.util.List; public class BTree { public BTree left; public BTree right; public BTree root; private Object data; //节点存入 .
Java实现二叉树
热门推荐
oneTreeTallTall
07-03 2万+
二叉树的定义 树（tree）是一种抽象数据类型（ADT），用来模拟具有树状结构性质的数据集合。它是由n（n>0）个有限节点通过连接它们的边组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的树。 二叉树是一种特殊的树，每个节点最多只能有两个子节点。（如图1.1） 二叉搜索树要求：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的...
JAVA 实现二叉树（链式存储结构）
09-02
总的来说，理解和实现二叉树是理解数据结构和算法的基础，这对于任何Java开发者来说都是至关重要的技能。通过这种方式，你可以更好地处理复杂的问题，优化代码性能，并为高级算法如排序和搜索奠定基础。
数据结构二叉树的Java实现
baidu_41860619的博客
12-17 524
本篇博文用java实现了数据结构中的二叉树 源码分享在github:数据结构，当然你也可以从下面的代码片中获取 1.二叉树节点类 BiTreeNode.java package code.tree; public class BiTreeNode { public Object data;//节点的数据域 public BiTreeNode lChild,rChild;//左右孩...
在JAVA中实现二叉树结构
天平的专栏
05-05 944
 最近研究了一下二叉树结构，参考了一些资料，总结了一下。package com.test;/** *//** *  * 在JAVA中实现二叉树结构 *  * 讲解： * 二个方法函数，一个寻找关键字－－searchkey 另一个是插入一个结点：insertTree  *  * 另外这是一个完全的先序遍历二叉树的语法。先根结点，再左结点，如无再右结点，如些加归至 *  * 搜索完毕。 *  
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值