2—3树 Java实现

最新推荐文章于 2023-10-30 09:39:51 发布
最新推荐文章于 2023-10-30 09:39:51 发布
阅读量459 收藏 3
点赞数 2
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45672914/article/details/108145930
版权

如果觉得代码注释不清晰、读不懂，或者有其他问题，欢迎留言或者私聊。
如果有大佬觉得哪里有错误也欢迎指正

public class BTreeDemo {
    public static void main(String[] args) {
        ArrayList<Data> arrayList = new ArrayList<Data>();
        arrayList.add(new Data(16));
        arrayList.add(new Data(24));
        arrayList.add(new Data(12));
        arrayList.add(new Data(32));
        arrayList.add(new Data(14));
        arrayList.add(new Data(26));
        arrayList.add(new Data(34));
        arrayList.add(new Data(10));
        arrayList.add(new Data(8));
        arrayList.add(new Data(28));
        arrayList.add(new Data(38));
        arrayList.add(new Data(20));
        BTree bTree = new BTree();
        for (Data data :arrayList) {
            bTree.add(data);
        }
        bTree.show();
    }
}

class BTree {
    Indexes head;
    public void add(Data data) {
        Indexes replace = head;
        if (head == null) {
            head = new Indexes(data);
        } else {
            addDemo(replace,data);
        }
    }
    public void addDemo(Indexes indexes,Data data) {
        if (data.data < indexes.data1.data && indexes.data2 == null) {//子树小于第一个点，并且第二个数为空
            if (indexes.left==null) {//无子树
                indexes.data2 = indexes.data1;
                indexes.data1 = data;
            } else if (indexes.left.left == null) {//有子树且子树无子树
                if (indexes.left.data2 == null) {//左子树无第二个数
                    if (data.data > indexes.left.data1.data) {//参数值大于左子树data1
                        indexes.left.data2 = data;
                    } else {
                        indexes.left.data2 = indexes.left.data1;
                        indexes.left.data1 = data;
                    }
                } else if (data.data < indexes.left.data1.data) {//参数值小于左子树第一个点并且有左子树第二个点
                    indexes.data2 = indexes.data1;
                    indexes.data1 = indexes.left.data1;
                    indexes.middle = new Indexes(indexes.left.data2);
                    indexes.left.data1 = data;
                    indexes.left.data2 = null;
                } else if (data.data > indexes.left.data1.data && data.data < indexes.left.data2.data) {//参数处于左子树第一个值和第二个值之间
                    indexes.middle = new Indexes(indexes.left.data2);
                    indexes.data2 = indexes.data1;
                    indexes.data1 = data;
                    indexes.left.data2 = null;
                } else if (data.data > indexes.left.data1.data) {//参数大于左子树第二个值
                    indexes.middle = new Indexes(data);
                    indexes.data2 = indexes.data1;
                    indexes.data1 = indexes.left.data2;
                    indexes.left.data2 = null;
                }
            } else {
                addDemo(indexes.left,data);
            }
        } else if (data.data > indexes.data1.data && indexes.data2 == null) {//data大于indexes第一个点,并且无第二个点
            //无子树情况
            if (indexes.right == null){
                indexes.data2 = data;
            } else if (indexes.right.right == null) {//有子树情况
                if (indexes.right.data2 == null) {//右子树没有第二个值
                    if (data.data < indexes.right.data1.data) {
                        indexes.right.data2 = indexes.right.data1;
                        indexes.right.data1 = data;
                    } else {
                        indexes.right.data2 = data;
                    }
                } else if (data.data > indexes.right.data2.data) {//参数值大于右子树第二个值
                    indexes.middle = new Indexes(indexes.right.data1);
                    indexes.data2 = indexes.right.data2;
                    indexes.right.data2 = null;
                    indexes.right.data1 = data;
                } else if (data.data > indexes.right.data1.data && data.data < indexes.right.data2.data) {//参数处于右子树第一个值和第二个值之间
                    indexes.middle = new Indexes(indexes.right.data1);
                    indexes.data2 = data;
                    indexes.right.data1 = indexes.right.data2;
                    indexes.right.data2 = null;
                } else if (data.data < indexes.right.data1.data) {//参数小于右子树第一个值
                    indexes.middle = new Indexes(data);
                    indexes.data2 = indexes.right.data1;
                    indexes.right.data1 = indexes.right.data2;
                    indexes.right.data2 = null;
                }
            } else {
                addDemo(indexes.right,data);
            }
        } else if (data.data < indexes.data1.data) {//参数小于data1 并且有data2
            if (indexes.left == null) {//无子树
                indexes.right = new Indexes(indexes.data2);
                indexes.data2 = null;
                indexes.left = new Indexes(data);
            } else if (indexes.left.left == null) {//子树无子树

                if (indexes.left.data2 == null) {//左子树无第二个值
                    if (data.data < indexes.left.data1.data) {
                        indexes.left.data2 = indexes.left.data1;
                        indexes.left.data1 = data;
                    } else {
                        indexes.left.data2 = data;
                    }
                } else{
                    if (data.data < indexes.left.data1.data) {//参数值小于左子树第一个值
                        indexes.left.left = new Indexes(data);
                        indexes.left.right = new Indexes(indexes.left.data2);
                        indexes.left.data2 = null;
                        Indexes newIndexes3 = new Indexes(indexes.data2);
                        newIndexes3.right = indexes.right;
                        newIndexes3.left = indexes.middle;
                        indexes.right = newIndexes3;
                        indexes.middle = null;
                        indexes.data2 = null;
                    } else if (data.data > indexes.left.data1.data && data.data < indexes.left.data2.data) {//参数值处在中间
                        indexes.left.left = new Indexes(indexes.left.data1);
                        indexes.left.right = new Indexes(indexes.data2);
                        indexes.left.data1 = data;
                        indexes.data2 = null;
                        Indexes newIndexes3 = new Indexes(indexes.data2);
                        newIndexes3.right = indexes.right;
                        newIndexes3.left = indexes.middle;
                        indexes.right = newIndexes3;
                        indexes.middle = null;
                        indexes.data2 = null;
                    } else if (data.data > indexes.left.data2.data) {//参数值大于第二个点
                        indexes.left.left = new Indexes(indexes.left.data1);
                        indexes.left.right = new Indexes(data);
                        indexes.left.data1 = indexes.left.data2;
                        indexes.data2 = null;
                        Indexes newIndexes3 = new Indexes(indexes.data2);
                        newIndexes3.right = indexes.right;
                        newIndexes3.left = indexes.middle;
                        indexes.right = newIndexes3;
                        indexes.middle = null;
                        indexes.data2 = null;
                    }
                }
            } else {
                addDemo(indexes.left,data);
            }
        } else if (data.data > indexes.data1.data && data.data < indexes.data2.data) {//参数值介于data1和data2之间
            if (indexes.middle == null) {//无子树情况
                indexes.right = new Indexes(indexes.data2);
                indexes.data2 = null;
                indexes.right = new Indexes(indexes.data1);
                indexes.data1 = data;
            } else if (indexes.middle.left == null) {

                if (indexes.middle.data2 == null) {
                    if (data.data < indexes.middle.data1.data) {
                        indexes.middle.data2 = indexes.middle.data1;
                        indexes.middle.data1 = data;
                    } else {
                        indexes.middle.data2 = data;
                    }
                } else {
                    if (data.data < indexes.middle.data1.data) {//小于中间data1
                        //左侧
                        Indexes indexes1 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            indexes1.data2 = indexes.left.data2;
                        }
                        indexes.left.left = indexes1;

                        indexes.left.right = new Indexes(data);

                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;
                        //右侧
                        Indexes indexes3 = new Indexes(indexes.right.data1);
                        if (indexes.right.data2 != null) {
                            indexes3.data2 = indexes.right.data2;
                        }
                        indexes.right.right = indexes3;

                        indexes.right.left = new Indexes(indexes.middle.data2);

                        indexes.right.data1 = indexes1.data2;
                        indexes.right.data2 = null;
                        //中间
                        indexes.data1 = indexes.middle.data1;
                        indexes.data2 = null;
                        indexes.middle = null;
                    } else if (data.data > indexes.middle.data1.data && data.data < indexes.middle.data2.data) {
                        Indexes indexes1 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            indexes1.data2 = indexes.left.data2;
                        }
                        indexes.left.left = indexes1;

                        indexes.left.right = new Indexes(indexes.middle.data1);

                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;
                        //右侧
                        Indexes indexes3 = new Indexes(indexes.right.data1);
                        if (indexes.right.data2 != null) {
                            indexes3.data2 = indexes.right.data2;
                        }
                        indexes.right.right = indexes3;

                        indexes.right.left = new Indexes(indexes.middle.data2);

                        indexes.right.data1 = indexes1.data2;
                        indexes.right.data2 = null;
                        //中间
                        indexes.data1 = data;
                        indexes.data2 = null;
                        indexes.middle = null;
                    } else if (data.data > indexes.middle.data2.data) {
                        //左侧
                        Indexes indexes1 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            indexes1.data2 = indexes.left.data2;
                        }
                        indexes.left.left = indexes1;

                        indexes.left.right = new Indexes(indexes.middle.data1);

                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;
                        //右侧
                        Indexes indexes3 = new Indexes(indexes.right.data1);
                        if (indexes.right.data2 != null) {
                            indexes3.data2 = indexes.right.data2;
                        }
                        indexes.right.right = indexes3;

                        indexes.right.left = new Indexes(data);

                        indexes.right.data1 = indexes1.data2;
                        indexes.right.data2 = null;
                        //中间
                        indexes.data1 = indexes.middle.data2;
                        indexes.data2 = null;
                        indexes.middle = null;
                    }
                }
            } else {
                addDemo(indexes.middle,data);
            }
        } else if (data.data > indexes.data2.data) {//大于data2
            if (indexes.right == null) {//无子树
                indexes.right = new Indexes(data);
                indexes.right = new Indexes(indexes.data1);
                indexes.data1 = indexes.data2;
                indexes.data2 = null;
            } else if (indexes.right.right == null) {//子树无子树

                if (indexes.right.data2 == null) {//右子树无第二个值
                    if (data.data < indexes.right.data1.data) {//参数值小于右子树data1
                        indexes.right.data2 = indexes.right.data1;
                        indexes.right.data1 = data;
                    } else {
                        indexes.right.data2 = data;
                    }
                } else {
                    if (data.data < indexes.right.data1.data) {//参数值小于左子树第一个值
                        indexes.right.right = new Indexes(indexes.right.data2);
                        indexes.right.data2 = null;

                        indexes.right.left = new Indexes(data);

                        Indexes newIndexes3 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            newIndexes3.data2 = indexes.left.data2;
                        }
                        indexes.left.left = newIndexes3;
                        Indexes newIndexes4 = new Indexes(indexes.middle.data1);
                        if (indexes.middle.data2 != null) {
                            newIndexes4.data2 = indexes.middle.data2;
                        }
                        indexes.left.right = newIndexes4;
                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;

                        indexes.data1 = indexes.data2;
                        indexes.data2 = null;
                        indexes.middle = null;
                    } else if (data.data > indexes.right.data1.data && data.data < indexes.right.data2.data) {//参数值处在中间
                        indexes.right.right = new Indexes(indexes.right.data2);

                        indexes.right.left = new Indexes(indexes.right.data1);

                        indexes.right.data1 = data;
                        indexes.right.data2 = null;

                        Indexes newIndexes3 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            newIndexes3.data2 = indexes.left.data2;
                        }
                        indexes.left.left = newIndexes3;
                        Indexes newIndexes4 = new Indexes(indexes.middle.data1);
                        if (indexes.middle.data2 != null) {
                            newIndexes4.data2 = indexes.middle.data2;
                        }
                        indexes.left.right = newIndexes4;
                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;

                        indexes.data1 = indexes.data2;
                        indexes.data2 = null;
                        indexes.middle = null;
                    } else if (data.data > indexes.right.data2.data) {//参数值大于第二个点
                        indexes.right.right = new Indexes(data);

                        indexes.right.left = new Indexes(indexes.right.data1);

                        indexes.right.data1 = indexes.right.data2;
                        indexes.right.data2 = null;

                        Indexes newIndexes3 = new Indexes(indexes.left.data1);
                        if (indexes.left.data2 != null) {
                            newIndexes3.data2 = indexes.left.data2;
                        }
                        indexes.left.left = newIndexes3;
                        Indexes newIndexes4 = new Indexes(indexes.middle.data1);
                        if (indexes.middle.data2 != null) {
                            newIndexes4.data2 = indexes.middle.data2;
                        }
                        indexes.left.right = newIndexes4;
                        indexes.left.data1 = indexes.data1;
                        indexes.left.data2 = null;

                        indexes.data1 = indexes.data2;
                        indexes.data2 = null;
                        indexes.middle = null;
                    }
                }
            } else {
                addDemo(indexes.right,data);
            }
        }
    }

    public void show() {
        Indexes replace = head;
        if (head == null) {
            System.out.println("空表");
        } else {
            showDemo(replace);
        }
    }

    public void showDemo(Indexes indexes) {
        System.out.print(indexes.data1.data);
        if (indexes.data2 != null) {
            System.out.println(indexes.data2.data);
        } else {
            System.out.println();
        }

        if (indexes.left != null) {
            System.out.println("要向左走");
            showDemo(indexes.left);
        }
        if (indexes.middle != null) {
            System.out.println("要向中间走");
            showDemo(indexes.middle);
        }
        if (indexes.right != null) {
            System.out.println("要向右走");
            showDemo(indexes.right);
        }
    }

    public boolean judgeSubTree(Indexes indexes) {
        return indexes.left != null && indexes.right != null;
    }
}
class Indexes {
    Data data1, data2;
    Indexes left,right,middle;
    Indexes(Data data) {
        this.data1 = data;
    }
}

class Data {
    int data;

    Data(int data) {
        this.data = data;
    }
}
王木风
关注
专栏目录
数据结构————————————————java写一个2-3树（只有插入）
go_____________ahead的博客
12-14 384
2-3树的特点： 1.2-节点至少有一个数据项和两个节点，它小于它的右孩子数据大于左孩子数据 2.3-节点必定包含两个数据S,L,它的左孩子的数据小于S，中孩子的数据大于S小于L，而右孩子大的数据于L 3.叶子可以包含一个或者两个数据                                   2-节点                                     ...
Java实现简单树结构
08-31
本篇将详细讲解如何使用Java实现一个简单的树结构，包括树节点类`treeNode`、树类`tree`以及相关的操作方法。 首先，我们来看`treeNode`类的实现。`treeNode`代表树中的一个节点，它可以存储任意类型的数据，这里用...
Java数据结构与算法解析(十)——2-3树
热门推荐
一个码农的博客
10-01 1万+
二叉查找树对于大多数情况下的查找和插入在效率上来说是没有问题的，但是他在最差的情况下效率比较低。平衡查找树的数据结构能够保证在最差的情况下也能达到lgN的效率，要实现这一目标我们需要保证树在插入完成之后始终保持平衡状态，这就是平衡查找树(Balanced Search Tree)。在一棵具有N 个节点的树中，我们希望该树的高度能够维持在lgN左右，这样我们就能保证只需要lgN次比较操作就可以查找到想
2-3树原理+代码实现！超简单java入门版！
title_martin的博客
01-21 491
2-3查找树 为了保证树的平衡性，我们需要一些灵活性，因此在这里我们允许树中的一个结点保存多个键，确切的说，我们将一颗标准的二叉查找树的结点称为2-结点(含有一个键和两条链)。而现在我们引入3-结点，它含有两个键和3条链。2-和3-结点中的每条链对应着其中保存的键所产生的一个区间。 定义： 一颗2-3树要么为空，要么满足下面两个要求： 2-结点： 含有一个键，及其对应值得两条链，左链接指向2-3树中的键都小于该结点，右链接指向2-3树中的键都大于该结点 3-结点： 含有两个键(及其对应的值)和3条链
浅谈算法和数据结构: 八 平衡查找树之2-3树
weixin_34357928的博客
03-25 441
前面介绍了二叉查找树(Binary Search Tree)，他对于大多数情况下的查找和插入在效率上来说是没有问题的，但是他在最差的情况下效率比较低。本文及后面文章介绍的平衡查找树的数据结构能够保证在最差的情况下也能达到lgN的效率，要实现这一目标我们需要保证树在插入完成之后始终保持平衡状态，这就是平衡查找树(Balanced Search Tree)。在一棵具有N 个节点的树中，我们希望该树的高...
java实现2-3树_Java数据结构和算法(八)--红黑树与2-3树
weixin_39767124的博客
02-27 341
红黑树规则：1、每个节点要么是红色，要么是黑色2、根节点都是黑色节点3、每个叶节点是黑色节点3、每个红色节点的两个子节点都是黑色节点，反之，不做要求，换句话说就是不能有连续两个红色节点4、从任意节点到所有叶子节点上的黑色节点数量是相同的一般对红黑树的讲述都是先给出这样的定义，这样想对不太容易理解的，而在算法4一书中，直接跳过这些规则，而讲述了红黑树与2-3树的等价性。如果我们先了解2-3树，理解了...
Java中树的存储结构实现示例代码
08-29
"Java中树的存储结构实现示例代码" 树是一种非线性结构，Java中树的存储结构实现示例代码中，树的存储结构是一种重要的数据结构。树的存储结构可以分为两种：一是数组存储结构，二是链表存储结构。在Java中，通常...
btree:用Java实现B树
05-04
用Java实现B树。 它实现了B树。 参见 。 它与标准{@link java.util.Set}兼容。 它使用数组来减少LinkedList的内存分配开销，该开销更易于处理溢出和联接/合并操作。 因为它在添加键时使用数组，所以应将所有键的...
决策树Java代码实现
03-03
决策树的Java实现涉及多个关键概念和技术点，包括但不限于节点的定义、数据结构的选择、属性的选择等。通过上述分析，我们不仅了解了决策树的基本原理，还深入了解了其在Java中的具体实现方式。这对于理解和开发实际...
基于java实现的决策树代码
11-14
此外，ID3算法对于连续值处理和处理多值特征有限，因此后续出现了C4.5和CART等改进算法，它们在Java实现时也值得关注。 总之，这个基于Java的决策树项目涵盖了从数据读取、模型训练到预测和评估的全过程，是深入...
Java 2-3树
抛弃幻想，准备斗争
04-19 551
2-3树满足二分搜索树的基本性质。 节点可以存放一个元素或者两个元素。 2-3树：每个节点有2个或者3个孩子，如果节点存放两个元素，左子节点的值小于b的值，中间节点的值在bc的范围之间，右子节点的值大于c的值。 2-3树是一棵绝对平衡的树。2-3树添加元素不会添加到空的位置。 比如有一棵树只有一个根节点42，想要插入一个37，由于42的子节点为空，且42所处的节点只有一个元素，所以...
2-3树的java实现
上帝已逝，自求多福
04-19 2127
点的定义 空点的定义 package TwoThreeTree; /** * A hole node does not have any values, and have only one child. */ final class HoleNode extends Node { private Node child; HoleNode()
2-3 查找树及其Java实现
weixin_30289831的博客
07-26 382
2-3 查找树 定义（来源：wiki） 查找 插入 2-3 查找树 定义（来源：wiki） 2–3树是一种树型数据结构，内部节点（存在子节点的节点）要么有2个孩子和1个数据元素，要么有3个孩子和2个数据元素，叶子节点没有孩子，并且有1个或2个数据元素。 2个结点 ...
java 树 查找_2-3 查找树及其Java实现
weixin_39606361的博客
02-12 313
2-3 查找树定义(来源：wiki)2–3树是一种树型数据结构，内部节点(存在子节点的节点)要么有2个孩子和1个数据元素，要么有3个孩子和2个数据元素，叶子节点没有孩子，并且有1个或2个数据元素。2个结点 定义如果一个内部节点拥有一个数据元素、两个子节点，则此节点为2节点。如果一个内部节点拥有两个数据元素、三个子节点，则此节点为3节点。当且仅当以下叙述中有一条成立时，T为2–3树：T为空。即T不包...
2-3-4树(java实现)
的博客
03-25 590
什么是2-3-4树？ 每个节点最多包含三个数据项，4个子节点 数据项按顺序排列 子节点的数据项,按此节点数据项按顺序寻找并按顺序插入到子节点 查找 和二叉树不同的是，每一个节点含有三个数据项，因此每到一个节点都会进行1-3次比较，因此查找的效率是m*log(N+1), m是每个节点的平均数据项的个数 插入 但在插入过程中遇到满结点时，就需要产生分裂，分裂后再继续向下查找到叶子节点并插入 分裂 ...
2-3-4树的java实现
weixin_34177064的博客
01-12 275
一、什么是2-3-4树 2-3-4树和红黑树一样，也是平衡树。只不过不是二叉树，它的子节点数目可以达到4个。 每个节点存储的数据项可以达到3个。名字中的2,3,4是指节点可能包含的子节点数目。具体而言： 1、若父节点中存有1个数据项，则必有2个子节点。 2、若父节点中存有2个数据项，则必有3个子节点。 3、若父节点中存有3个数据项，则必有4个子节点。 也就是说子节点的数目是父节...
2-3查找树-树-数据结构和算法(Java)
gaogzhen的博客
12-13 504
2-3查找树-树-数据结构和算法(Java)
2-3树—＞红黑树【java实现】
最新发布
weixin_63541561的博客
10-30 559
添加完成后的2-3树，将出现三节点的左边记为红色，下来就可以向左下拉变成红黑树了。节点可以存放一个元素或两个元素，因此孩子节点可以为两个或三个。5.根节点到任意叶子结点的黑色节点的数目相同。4.红色节点的孩子节点一定都是黑色节点。3.叶子结点是（null）黑色。1.节点不是黑色就是红色。添加时需要调整的五种情况。下拉后变为一棵红黑树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值