java中的跳过列表删除和打印方法

我致力于用java实现跳过列表。我有一个插入和搜索的方法。但我不能写删除和打印方法。下面是代码：SkipList.java

    public class SkipList<T extends Comparable<T>> {

    private SkipNode<T> start;
    private SkipNode<T> end;
    private SkipNode<T> supportStart;
    private SkipNode<T> supportEnd;
    private int size;
    private int sizeSupport;

    public T getStart() {
        return start.getData();
    }

    public T getEnd() {
        return end.getData();
    }

    public int getSize() {
        return size;
    }

    public void add(T data) {
        if (start == null) {
            insertAsFirstElement(data);
        } else {
            insert(data);
        }
    }

    private void insertAsFirstElement(T data) {
        SkipNode<T> node = new SkipNode<>(data);
        start = node;
        end = node;
        size++;

        SkipNode<T> supportNode = new SkipNode<>(data);
        supportStart = supportNode;
        supportEnd = supportNode;
        supportNode.setDown(node);
        sizeSupport++;
    }

//Adding element in the end assuming user enters data in ascending order
    private void insert(T data) {
        SkipNode<T> node = new SkipNode<>(data);
        end.setNext(node);
        node.setPrevious(end);
        end = node;
        size++;

        int expectedSupportSize = (int) Math.sqrt(size);
        if (sizeSupport < expectedSupportSize) {
            SkipNode<T> supportNode = new SkipNode<>(data);
            supportEnd.setNext(supportNode);
            supportNode.setPrevious(supportEnd);
            supportEnd = supportNode;
            supportNode.setDown(node);
            sizeSupport++;

            if (sizeSupport > 2) {
                reAjustSupportList();
            }

        }
    }





    private void reAjustSupportList() {
        SkipNode<T> navigationNode = supportStart.getNext();
        int i = 1;

        while (navigationNode != supportEnd) {
            SkipNode<T> tempNode = navigationNode.getDown();
            for (int j = 1; j <= i; j++) {
                tempNode = tempNode.getNext();
            }
            navigationNode.setDown(tempNode);
            navigationNode.setData(tempNode.getData());
            navigationNode = navigationNode.getNext();

            i++;
        }
    }

    public boolean search(T data) {
    SkipNode<T> navigationNode = supportStart;
    int compare;

    while ((compare = data.compareTo(navigationNode.getData())) > 0
            && navigationNode.getNext() != null) {
        navigationNode = navigationNode.getNext();
    }

    if (compare == 0) {
        return true;
    }

    if (compare < 0) {
        navigationNode = navigationNode.getPrevious();
    }
    navigationNode = navigationNode.getDown().getNext();

    while ((compare = data.compareTo(navigationNode.getData())) > 0
            && navigationNode.getNext() != null) {
        navigationNode = navigationNode.getNext();
    }
    return compare == 0;
}



    private static class SkipNode<T> {

        public SkipNode(T data) {
            this.data = data;
        }

        private SkipNode<T> next = null;
        private SkipNode<T> previous = null;
        private SkipNode<T> down = null;
        private T data;

        public SkipNode<T> getNext() {
            return next;
        }

        public void setNext(SkipNode<T> next) {
            this.next = next;
        }

        public SkipNode<T> getPrevious() {
            return previous;
        }

        public void setPrevious(SkipNode<T> previous) {
            this.previous = previous;
        }

        public SkipNode<T> getDown() {
            return down;
        }

        public void setDown(SkipNode<T> down) {
            this.down = down;
        }

        public T getData() {
            return data;
        }

        public void setData(T data) {
            this.data = data;
        }
    }

    public static void main(String[] args) {

        SkipList<Integer> mylist = new SkipList<Integer>();

         mylist.add(12);
         mylist.add(23);
         mylist.add(30);
         mylist.add(20);
         mylist.add(45);
         mylist.add(34);

         System.out.println("Size of liked list equals:"+ mylist.size);
         System.out.println(mylist.search(12));  // true
         System.out.println(mylist.search(45));  //true
         System.out.println(mylist.search(40));  // false



    } 
}

公共类SkipList{
专用SkipNode启动；
私有SkipNode端；
私有SkipNode支持启动；
私有SkipNode支持端；
私有整数大小；
私有整数支持；
公共T getStart（）{
返回start.getData（）；
}
公共T getEnd（）{
返回end.getData（）；
}
公共int getSize（）{
返回大小；
}
公共无效添加（T数据）{
if（start==null）{
插入文件（数据）；
}否则{
插入（数据）；
}
}
专用void insertAsFirstElement（T数据）{
SkipNode节点=新SkipNode（数据）；
开始=节点；
结束=节点；
大小++；
SkipNode supportNode=新的SkipNode（数据）；
supportStart=supportNode；
supportEnd=supportNode；
supportNode.setDown（节点）；
sizeSupport++；
}
//假设用户按升序输入数据，则在末尾添加元素
专用无效插入（T数据）{
SkipNode节点=新SkipNode（数据）；
end.setNext（节点）；
node.setPrevious（结束）；
结束=节点；
大小++；
int expectedSupportSize=（int）Math.sqrt（size）；
if（大小支持<预期支持大小）{
SkipNode supportNode=新的SkipNode（数据）；
supportEnd.setNext（supportNode）；
supportNode.setPrevious（supportEnd）；
supportEnd=supportNode；
supportNode.setDown（节点）；
sizeSupport++；
如果（大小支持>2）{
reAjustSupportList（）；
}
}
}
私有void reAjustSupportList（）{
SkipNode navigationNode=supportStart.getNext（）；
int i=1；
while（navigationNode！=supportEnd）{
SkipNode tempNode=navigationNode.getDown（）；
对于（int j=1；j 0
&&navigationNode.getNext（）！=null）{
navigationNode=navigationNode.getNext（）；
}
如果（比较==0）{
返回true；
}
如果（比较<0）{
navigationNode=navigationNode.getPrevious（）；
}
navigationNode=navigationNode.getDown（）.getNext（）；
而（（compare=data.compareTo（navigationNode.getData（）））>0
&&navigationNode.getNext（）！=null）{
navigationNode=navigationNode.getNext（）；
}
返回比较==0；
}
私有静态类SkipNode{
公共SkipNode（T数据）{
这个数据=数据；
}
private SkipNode next=null；
private SkipNode previous=null；
private SkipNode down=null；
私有T数据；
公共SkipNode getNext（）{
下一步返回；
}
public void setNext（SkipNode next）{
this.next=next；
}
公共SkipNode getPrevious（）{
返回上一个；
}
public void setPrevious（SkipNode previous）{
this.previous=先前；
}
公共SkipNode getDown（）{
返回下来；
}
公共无效设置（SkipNode down）{
this.down=向下；
}
公共T getData（）{
返回数据；
}
公共无效设置数据（T数据）{
这个数据=数据；
}
}
公共静态void main（字符串[]args）{
SkipList mylist=新SkipList（）；
mylist.add（12）；
mylist.add（23）；
增加（30）；
添加（20）；
mylist.add（45）；
mylist.add（34）；
System.out.println（“喜欢的列表的大小等于：“+mylist.Size”）；
System.out.println（mylist.search（12））；//true
System.out.println（mylist.search（45））；//true
System.out.println（mylist.search（40））；//false
} 
}

我试图通过打印获得的列表

for(int i=1;i<mylist.size;i++)
         {
             System.out.println(mylist[i]);
         }

---

for（int i=1；i为什么你在1开始
i
呢？那是一个打字错误，是的，我改了，但它不起作用。我怎么写那些方法呢？你能帮我吗？你为什么在1开始
i
呢？那是一个打字错误，是的，我改了，但它不起作用。我怎么写那些方法呢？你能帮我吗？