自己写的代码 跳跃表

public class SkipList<T> {

  //允许最大的层级s

    int maxlevel=4;
    //表头节点
    SkipListHeadNode head=new SkipListHeadNode();
    //最大层数
    int level;
    //节点长度
    int length;
    Random random=new Random();
    //抛硬币随机
    int randomLevel(){
        return random.nextInt(maxlevel)+1;
    }
    public void insertNode(int score,T value){
        int levelnum=randomLevel();//抛硬币
        System.out.println(score+","+levelnum);
        SkipListNode newnode=new SkipListNode(score, levelnum, value);
        
        //每次都在头节点添加
        //head.add(newnode);
        head.insert(newnode);
        length++;
    }
    /**
     * 查找 两个分值区间的数
     * @param startScore
     * @param endScore
     * @return
     */
    public Map<T, Integer> findRegionNode(int startScore, int endScore) {
        int currentHeadlevel = level;
        Map<T, Integer> map = new TreeMap();
        //找到最近接小于startScore节点
        SkipListNode startbeforNode;
        //开始节点 score>=startScore
        SkipListNode startNode = null;
        for (; currentHeadlevel > 0; currentHeadlevel--) {// 循环找开始节点
            SkipListNodeLevel cuurentheadlevel = head.getSkipListNodeLevel()[currentHeadlevel - 1];
            SkipListNode currheadnode = cuurentheadlevel.nextnode;
           
            if (currheadnode != null && currheadnode.score < startScore) {
                startbeforNode = currheadnode;
                 //找到最近接小于startScore节点的位置
                loopFindBeforStart(startScore, startbeforNode);
                //
                SkipListNode node = startbeforNode.getSkipListNodeLevel()[0].nextnode;
                if (node != null) {
                    startNode = node;
                }
                break;
            }

            if (currentHeadlevel == 1 && currheadnode.score < endScore) {// 最后一个
                startNode = currheadnode;
            }
        }
        if(startNode==null){
            return null;
        }
        map.put((T) startNode.value, startNode.score);
        SkipListNode hitNode=startNode.getSkipListNodeLevel()[0].nextnode;
        while(hitNode!=null&hitNode.score<=endScore){
            map.put((T) hitNode.value, hitNode.score);
            hitNode=hitNode.getSkipListNodeLevel()[0].nextnode;
        }
        
        return map;

    }
    //开始计数最接近节点
    private void loopFindBeforStart(int startScore, SkipListNode startbeforNode) {
        int hitlength = startbeforNode.getSkipListNodeLevel().length;
        for(;hitlength>0;hitlength--){
            SkipListNodeLevel currlevel=    startbeforNode.getSkipListNodeLevel()[hitlength-1];
            SkipListNode currnode=currlevel.nextnode;
            if(currnode!=null&&currnode.score<startScore){
                startbeforNode=currnode;
                loopFindBeforStart(startScore,startbeforNode);
                break;
            }
        }
    }
    
    
    public SkipListHeadNode getHead() {
        return head;
    }
    public void setHead(SkipListHeadNode head) {
        this.head = head;
    }
    
    public int getLength() {
        return length;
    }
    public void setLength(int length) {
        this.length = length;
    }


    /**
     * 头节点
     * 导航个节点的
     * @author daodao
     *
     */
    class SkipListHeadNode{
        //等级节点
        SkipListNodeLevel[] skipListNodeLevel=new SkipListNodeLevel[maxlevel];
        public void add(SkipListNode newaddNode){
            //扩容首节点长度
            if(newaddNode.getLevelNum()>level){
                level=newaddNode.getLevelNum();
            }
            
            int changelevelIndex=newaddNode.getLevelNum();
            
            SkipListNodeLevel[] headskipListNodeLevel=this.getSkipListNodeLevel();
            //设置等级指向新节点
            for(;changelevelIndex>0;changelevelIndex--){
                SkipListNodeLevel  headNodeLevel=headskipListNodeLevel[changelevelIndex-1];
                if(headNodeLevel==null){//表示该节点 目前
                    headskipListNodeLevel[changelevelIndex-1]=new SkipListNodeLevel(newaddNode,length+1);
                }else{
                    SkipListNode nextnode =headNodeLevel.getNextnode();
                    int lostspan=0;
                    setLevelNextNode(newaddNode, nextnode,lostspan);
                    break;
                }
            }
            
        }
        
        
        public void insert(SkipListNode newaddNode){
            int addnodelevelIndex=newaddNode.getLevelNum();
            SkipListNodeLevel newlevel=    new SkipListNodeLevel(newaddNode,1);
            if(length==0){
                for(;addnodelevelIndex>0;addnodelevelIndex--){
                        skipListNodeLevel[addnodelevelIndex-1]=newlevel;
                  }
            }else{
                
                for(;addnodelevelIndex>0;addnodelevelIndex--){
                   SkipListNodeLevel  headNodeLevel=skipListNodeLevel[addnodelevelIndex-1];
                   if(headNodeLevel==null){
                      skipListNodeLevel[addnodelevelIndex-1]=newlevel;
                    }else{
                        SkipListNode node=headNodeLevel.nextnode;
                        if(node.getScore()>=newaddNode.getScore())
                        {   
                            SkipListNodeLevel zhuanhuan=    skipListNodeLevel[addnodelevelIndex-1];
                            skipListNodeLevel[addnodelevelIndex-1]=newlevel;
                            newaddNode.getSkipListNodeLevel()[addnodelevelIndex-1]=zhuanhuan;
                        }else{
                            loopInsert(newaddNode, addnodelevelIndex, node,newlevel);
                        }
                    }
                }
                
            }
            
            
          if(level<newaddNode.levelNum){
              level=newaddNode.levelNum;
          }
            
        }

        //循环为每一级添加
        private void loopInsert(SkipListNode newaddNode, int addnodelevelIndex, SkipListNode node,SkipListNodeLevel newlevel) {
            SkipListNodeLevel nodelevel=node.getSkipListNodeLevel()[addnodelevelIndex-1];
            if(nodelevel==null){//在最后
                node.getSkipListNodeLevel()[addnodelevelIndex-1]=newlevel;
            }else{//在后面
                SkipListNode nextnode=nodelevel.nextnode;
                if(nextnode.getScore()>=newaddNode.getScore())
                {   
                    SkipListNodeLevel zhuanhuan=node.getSkipListNodeLevel()[addnodelevelIndex-1];
                    node.getSkipListNodeLevel()[addnodelevelIndex-1]=newlevel;
                    newaddNode.getSkipListNodeLevel()[addnodelevelIndex-1]=zhuanhuan;
                }else{
                    loopInsert(newaddNode,addnodelevelIndex,nextnode,newlevel);
                    return;
                }
            }
        }
        
        /**
         * 递归设置每一级的 nextnode
         * @param newaddNode
         * @param currnode
         * @param levelNumIndex
         */
        private void setLevelNextNode(SkipListNode newaddNode, SkipListNode currnode,int lostspan) {
            int levelNumIndex=newaddNode.getLevelNum();
            if(levelNumIndex>currnode.getLevelNum()){
                levelNumIndex=currnode.getLevelNum();
            }
            
            for(;levelNumIndex>0;levelNumIndex--){
                SkipListNodeLevel[] currentskipListNodeLevel=currnode.getSkipListNodeLevel();
                SkipListNodeLevel  ncurrLevel=currentskipListNodeLevel[levelNumIndex-1];
                
                if(ncurrLevel==null){//表示该节点 目前
                    currentskipListNodeLevel[levelNumIndex-1]=new SkipListNodeLevel(newaddNode,length+1-lostspan);
                }else{
                    lostspan=lostspan+ncurrLevel.getSpan();
                    SkipListNode newnextnode =ncurrLevel.getNextnode();
                    if(newnextnode==currnode){    
                        System.out.println("-----------"+currnode.score);
                    }
                    setLevelNextNode( newaddNode,  newnextnode,lostspan);
                    break;
                }
            }
        }


        public SkipListNodeLevel[] getSkipListNodeLevel() {
            return skipListNodeLevel;
        }

        public void setSkipListNodeLevel(SkipListNodeLevel[] skipListNodeLevel) {
            this.skipListNodeLevel = skipListNodeLevel;
        }
        
    }
    
    public void printSkipList(){
        System.out.println("-----开始遍历跳跃表-----");
        if(head==null){
            System.out.println("跳跃表没数据");
            System.out.println("-----遍历跳跃表结束-----");
            return;
        }
        
        //System.out.println(JSONObject.fromObject(this));
        
        int levelnum=level;
        int nodenum=length;
        for(;levelnum>0;levelnum--){
            System.out.print("打印第"+levelnum+"级");    
            
            SkipListNodeLevel  level=head.getSkipListNodeLevel()[levelnum-1];
            
            SkipListNode node=level.getNextnode();
            System.out.print("--"+node.score+"--"+node.value);
            
            while(node.getSkipListNodeLevel()[levelnum-1]!=null){
                 for(int i=0;i<level.getSpan();i++){
                        System.out.print("--##--");    
                    }
                node=node.getSkipListNodeLevel()[levelnum-1].nextnode;
                System.out.print("--"+node.score+"--"+node.value);
            }
            System.out.println("");    
        }
        
        
        System.out.println("-----遍历跳跃表结束-----");
    }
    
    public static void main(String[] args) {
        SkipList list=new SkipList();
        list.insertNode(4, "14");
        list.insertNode(1, "11");
        list.insertNode(3, "13");
        list.insertNode(2, "12");
        list.insertNode(5, "16cc");
        list.insertNode(7, "17");
        list.insertNode(8, "18");
        list.insertNode(6, "1666a");
       
        list.printSkipList();
        System.out.println(list.findRegionNode(2, 7));
    }
}

/**
 * 节点
 * @author daodao
 *
 */
class  SkipListNode<T>{
    //比较大小的分值 排序用
    int score;
    //保存值
    T value;
    //节点级数
    int levelNum;
    //等级节点
    SkipListNodeLevel[] SkipListNodeLevel;
    /**
     *
     * @param score 分值
     * @param levelNum 等级
     * @param value 保存值
     */
    public SkipListNode(int score,int levelNum,T value){
        this.score=score;
        this.levelNum=levelNum;
        this.value=value;
        SkipListNodeLevel=new SkipListNodeLevel[levelNum];
    }
    
    /*public querySkipListNodeLevel(int levelnum){
        SkipListNodeLevel
    }*/
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }
    public int getLevelNum() {
        return levelNum;
    }
    public void setLevelNum(int levelNum) {
        this.levelNum = levelNum;
    }
    public SkipListNodeLevel[] getSkipListNodeLevel() {
        return SkipListNodeLevel;
    }
    public void setSkipListNodeLevel(SkipListNodeLevel[] skipListNodeLevel) {
        SkipListNodeLevel = skipListNodeLevel;
    }
    
    
}
/**
 * 等级
 * @author daodao
 *
 */
class SkipListNodeLevel{
    //下一节点
    SkipListNode nextnode;
    //跨度 没实现
    int span;
    
    public SkipListNodeLevel(SkipListNode skipListNode,int span){
        this.nextnode=skipListNode;
        this.span=span;
    }

    public SkipListNode getNextnode() {
        return nextnode;
    }

    public void setNextnode(SkipListNode nextnode) {
        this.nextnode = nextnode;
    }

    public int getSpan() {
        return span;
    }

    public void setSpan(int span) {
        this.span = span;
    }
    
   
}