java实现VEBTree原型

最新推荐文章于 2024-06-25 21:10:40 发布

chenzhichao

最新推荐文章于 2024-06-25 21:10:40 发布

阅读量514

点赞数

分类专栏：学习与实践文章标签： java 算法导论 VEBTree 数据结构

本文链接：https://blog.youkuaiyun.com/chenzhichao/article/details/51526025

版权

学习与实践专栏收录该内容

8 篇文章

订阅专栏

本文将详细介绍如何使用Java实现VEBTree数据结构，该过程耗费了一周的时间，目前只完成了构建部分，后续会补充删除操作的代码实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

花了一周时间才想明白，稍后补上删除代码

package tree;

import java.lang.reflect.Array;

@SuppressWarnings("unchecked")
public class ProtoVEBTree {

    public Node root;

    public ProtoVEBTree(int length) {
        this.root = new Node(length);
    }

    public static class Node {
        protected int u;
        protected Object[] nodeArray;
        protected Node summary;

        /*
        Node的构造方法顺带初始化protoVEBTree
         */
        protected Node(int u) {
            this.u = u;
            if (u == 2) {
                this.summary = null;
                this.nodeArray = new Object[2];
                this.nodeArray[0] = this.nodeArray[1] = 0;
            } else {
                int childSize = (int) (Math.sqrt(u));
                this.nodeArray = (Object[]) (Array.newInstance(Node.class, childSize));
                for (int i = 0; i < this.nodeArray.length; i++)
                    this.nodeArray[i] = new Node(childSize);
                this.summary = new Node(childSize);
            }
        }

        protected int contain(int i) {
            if (u == 2)
                return (Integer) (this.nodeArray[i]);
            else
                return ((Node) (this.nodeArray[i / this.nodeArray.length])).contain(i % this.nodeArray.length);
        }

        protected Integer minNum() {
            if (u == 2)
                if ((Byte) (nodeArray[0]) == 1)
                    return 0;
                else if ((Byte) (nodeArray[1]) == 1)
                    return 1;
                else
                    return null;
            else {
                Integer minCluster = summary.minNum();//找出最小元素所在的簇号
                if (minCluster == null)
                    return null;
                else {
                    int offset = ((Node) (nodeArray[minCluster])).minNum();
                    return minCluster * nodeArray.length + offset;
                }
            }
        }

        public Integer successor(int x) {
            if (u == 2)
                if (x == 0 && ((Byte) (nodeArray[1])) == 1)
                    return 1;
                else
                    return null;
            else {
                int highx = x / nodeArray.length;
                Integer offset = ((Node) nodeArray[highx]).successor(x % nodeArray.length);//先假定next和x在同一簇，求得next的偏移值
                if (offset != null)
                    return highx * nodeArray.length + offset;
                else {//如果不在同一簇，先求出x所在簇的下一簇的簇号，然后求得下一簇的最小值
                    Integer successorCluster = summary.successor(highx);
                    return successorCluster == null ? null : successorCluster * nodeArray.length + ((Node) nodeArray[successorCluster]).minNum();
                }
            }
        }

        public void insert(int x) {
           if(u==2)
               nodeArray[x]=1;
            else{
               ((Node)(nodeArray[x/u])).insert(x%u);
               summary.insert(x/u);
           }
        }
    }

    public int contain(int i) {
        return this.root.contain(i);
    }

    public Integer minNum() {
        return this.root.minNum();
    }

    public Integer successor(int x) {
        return this.root.successor(x);
    }

    public void insert(int x) {
        root.insert(x);
    }

    public static void main(String[] args) {
        Node s = new Node(16);
        System.out.println("ok");
    }


}