Java实现数据结构---234树

N叉树简介

每个节点只有一个数据项，并且每个节点最多只有两个子节点的树称为二叉树。如果每个节点可以存多个（大于等于3）数据项，并且每个节点可以拥有多个（大于等于3）子节点的树称为N（大于等于3）叉树。N叉树相对于二叉树而言，存储相等数量的数据，N叉树因为同一层存放的数据变多，相应树的高度就变小，查询也就更快。

234树简介

234树的特点

234树是N叉树的一种，其中数字2、3、4可以认为是节点的子节点数量，234树主要有以下特点：

1. 一个节点最多可以存储3个数据项。
2. 一个节点（非叶节点）最多拥有4个子节点。
3. 数据项个数与子节点数量关系为：子节点数量 = 数据项个数 + 1。
   • 一个节点（非叶节点）存有1个数据项时，拥有2个子节点。
   • 一个节点（非叶节点）存有2个数据项时，拥有3个子节点。
   • 一个节点（非叶节点）存有3个数据项时，拥有4个子节点。
4. 234树中不存在空节点（没有数据项的节点），这个可以从后面的分裂看出来。

数据存放规则

假如一个节点中有三个数据项（从左往右为：D1，D2，D3），那么其4个子节点（从左往右为：C1，C2，C3，C4），有如下大小关系：C1节点数据项及其子节点数据项 < D1 < C2节点数据项及其子节点数据项 < D2 < C3节点数据项及其子节点数据项 < D3 < C4节点数据项及其子节点数据项 。

插入数据

234树插入数据，数据总是插入在叶子节点，跟二叉树一样会向下查找合适的叶子节点，再次过程中核能会发生一系列节点变换（节点分裂），找到叶子节点后，然后根据节点数据项排列顺序（左侧数据项 < 中间数据项 < 右侧数据项）将数据放入节点数据项中。

节点分裂

插入数据时，在向下寻找过程中如果遇到了数据项已经满了的节点（拥有三个数据项），将会对改节点进行分裂，假如节点三个数据项从左往右为D1、D2、D3，四个子节点从左往右分别为C1、C2、C3、C4，分裂规则是：

1. 将D2数据项上移，作为父节点的数据项（父节点最多只有两个数据项），创建分裂节点的兄弟节点，将D1数据项作为兄弟节点的数据项，C1，C2作为兄弟节点的子节点，分裂完毕。
2. 如果D2节点上移过程中，没有父节点，即分裂节点为根节点，则新建根节点，然后D2作为根节点的数据项。
   

代码实现

节点类

	package com.xxliao.datastructure.tree.twothreefour_tree;

/**
 * @author xxliao
 * @description: 234树节点类,这里为了简便实现，节点类的数据项为Integer数据
 * @date 2024/5/29 0:49
 */

public class Node {

    // 节点子节点数量最多为4
    private static final int CHILD_NODE_COUNT = 4;
    // 节点数据项个数
    private int dataItemCount;
    // 父节点
    private Node parent;
    // 子节点
    private Node[] children = new Node [CHILD_NODE_COUNT];
    // 节点数据项
    private Integer[] dataItems = new Integer [CHILD_NODE_COUNT -1];

    // 构造方法
    public Node() {
        this.dataItemCount = 0;
    }
    // 判断当前节点是否已满
    public boolean isFull() {

        return (dataItemCount == CHILD_NODE_COUNT -1);
    }
    // 获取父节点
    public Node getParent() {

        return parent;
    }

    // 获取指定位置的子节点
    public Node getChild(int childIndex) {

        return children[childIndex];
    }

    // 判断节点是否为叶子节点
    public boolean isLeafNode() {

        return children[0] == null;
    }

    // 获取节点的数据项个数
    public int getDataItemCount() {

        return dataItemCount;
    }

    // 获取指定位置的数据项
    public int getDataItem(int dataItemIndex) {

        return dataItems[dataItemIndex];
    }

    // 连接子节点
    public void connectChild(int childIndex, Node child) {
        if(child != null) {
            children[childIndex] = child;
            child.parent = this;
        }
    }

    // 去掉子节点
    public Node removeNode(int childIndex) {
        Node removeNode = children[childIndex];
        children[childIndex] = null;
        return removeNode;
    }

    // 查找具体数据项在数据项数组中的索引位置
    public int findDataItemIndex(Integer dataItem) {
        for(int i=0; i< CHILD_NODE_COUNT-1; i++) {
            if(dataItems[i] == null) {
                break;
            }else if(dataItems[i].equals(dataItem)) {
                return i;
            }
        }
        return -1;
    }

    //插入数据项
    public int insertItem(Integer newDataItem) {
        dataItemCount ++;
        for(int i=CHILD_NODE_COUNT-2; i>=0; i--) {
            if(dataItems[i] == null) {
                continue;
            }
            if(newDataItem < dataItems[i]) {
                dataItems[i+1] = dataItems[i];
            }else {
                dataItems[i+1] = newDataItem;
                return i+1;
            }
        }
        dataItems[0] = newDataItem;
        return 0;
    }

    //删除大数据项
    public Integer removeDataItem() {
        Integer removeDataItem = dataItems[dataItemCount - 1];
        dataItems[dataItemCount - 1] = null;
        dataItemCount --;
        return removeDataItem;
    }

    // 打印节点
    public void displayNode() {
        for (int i=0; i<dataItemCount; i++)  {
            System.out.println("/" + dataItems[i]);
        }
        System.out.println("/");
    }

}

234树实现

	package com.xxliao.datastructure.tree.twothreefour_tree;

/**
 * @author xxliao
 * @description: 234树实现类
 * @date 2024/5/29 0:51
 */

public class TwoThreeFourTree {
    
    // 根节点
    private Node root = new Node();

    // 利用当前节点和数据项的值,查找写一个子节点
    public Node getNextChild(Node currentNode, Integer nowDataItem) {
        // 获取当前节点的数据项个数
        int dataItemCount = currentNode.getDataItemCount();
        // 遍历比较
        for (int j = 0; j < dataItemCount; j++) {
            if (nowDataItem < currentNode.getDataItem(j)) {
                // 数据项比当前节点数据项比较,小于的话,返回左侧的子节点
                return currentNode.getChild(j);
            }
        }
        // 传入数据项值比当前节点数据项都大,返回最右侧子节点
        return currentNode.getChild(dataItemCount - 1);
    }

    // 判断否数据项是否存在
    public boolean isExist(Integer dataItem) {
        Node currentNode = root;
        while (true) {
            if (currentNode.findDataItemIndex(dataItem) != -1)
                // 在当前节点找到该数据项,返回索引
                return true;
            else if (currentNode.isLeafNode())
                return false;
            else
                currentNode = getNextChild(currentNode, dataItem);
        }
    }

    // 插入一个数据项
    public void add(Integer dataItem) {
        Node currentNode = root;
        while (true) {
            if (currentNode.isFull()) {
                // 当前节点满了,分裂当前节点
                split(currentNode);
                currentNode = currentNode.getParent();
                currentNode = getNextChild(currentNode, dataItem);
            } else if (currentNode.isLeafNode())
                break;
            else
                currentNode = getNextChild(currentNode, dataItem);
        }
        currentNode.insertItem(dataItem);
    }

    // 分裂节点
    public void split(Node currentNode) {
        // 定义从左到右 第二个数据项 和 第三个数据项
        Integer item, rightItem;
        // 定义父节点 ,以及最右侧两个子节点
        Node parent, child3, child4;
        int itemIndex;
        // 记录当前节点第三个数据项,并删除
        rightItem = currentNode.removeDataItem();
        // 记录当前节点第二个数据项,并删除
        item = currentNode.removeDataItem();
        // 记录当前节点第三个子节点,并删除
        child3 = currentNode.removeNode(2);
        // 记录当前节点第四个子节点,并删除
        child4 = currentNode.removeNode(3);
        // 创建分裂节点兄弟节点
        Node brotherNode = new Node();
        // 分裂节点的最大数据项作为兄弟节点的数据下个
        brotherNode.insertItem(rightItem);
        // 分裂节点的第三个和第四个子节点作为兄弟节点的子节点
        brotherNode.connectChild(0, child3);
        brotherNode.connectChild(1, child4);
        // 开始分裂
        if (currentNode == root) {
            // 根节点分裂情况,创建新的根节点,原根节点作为新根节点的子节点,并记录分裂节点的父节点
            root = new Node();
            parent = root;
            root.connectChild(0, currentNode);
        } else {
            // 记录分裂节点的父节点
            parent = currentNode.getParent();
        }
        // 将要分裂节点的的中间数据项插入到父节点中 并且获取到插入的索引
        itemIndex = parent.insertItem(item);
        // 获取父节点中数据项的个数
        int dataItemCount = parent.getDataItemCount();
        // 循环根据
        for (int j = dataItemCount - 1; j > itemIndex; j--) { //
            Node temp = parent.removeNode(j); // 父节点和要拆分的接待你断开连接
            parent.connectChild(j + 1, temp); // 父节点和要拆分的原节点重新连接 位置为原要拆分节点的中间的数据项在父节点中位置的左边
        }
        parent.connectChild(itemIndex + 1, brotherNode); // 然后在原要拆分节点新的位置的右边插入新的右边节点
    }

    // 打印一整棵树
    public void displayTree() {
        recDisplayTree(root, 0, 0);
    }

    // 打印树 传入要从那个节开始打 从那层开始的 哪个节点开始的 前序遍历
    private void recDisplayTree(Node thisNode, int level, int childNumber) {
        System.out.print("level=" + level + " child=" + childNumber + " "); // 先打印当前节点的状况
        thisNode.displayNode();

        int dataItemCount = thisNode.getDataItemCount();
        for (int j = 0; j < dataItemCount + 1; j++) { // 遍历每一个子节点并打印 递归
            Node nextNode = thisNode.getChild(j);
            if (nextNode != null) // 如果
                recDisplayTree(nextNode, level + 1, j); // 向下层递归
            else
                return; // 递归结束
        }
    }
}

完整代码

https://github.com/xxliao100/datastructure_algorithms.git