Java 双链表-删除和添加

这是一个类实验室，我试图在其中添加、删除等内容到一个双链接列表中。我相信我所拥有的是正确的。如果一个对象不是列表的开始或结束，我就很难弄清楚如何删除它。我对add方法也有类似的问题。非常感谢您对我当前代码的建议和评论

public class Double<T extends Comparable<T>> implements ListInterface<T> {

protected DLLNode<T> front; //Front of list
protected DLLNode<T> rear; //Rear of list
protected DLLNode<T> curPosition; //Current spot for iteration
protected int numElements; //Number of elements in list

public Double() {
    front = null;
    rear = null;
    curPosition = null;
    numElements = 0;
}

protected DLLNode<T> find(T target) {
    //While the list is not empty and the target is not equal to the current element
    //curr will move down the list. If curr becomes null then return null.
    //If it finds the element, return it.
    DLLNode<T> curr;
    curr = front;
    T currInfo = curr.getInfo();
    while(curr != null && currInfo.compareTo(target) != 0) {    
        curr = (DLLNode<T>)curr.getLink();      
    }
    if (curr == null) {
        return null;
    }
    else {
        return curr;
    }           
}

public int size() { 
    //Return number of elements in the list 
    return numElements;     
}

public boolean contains(T element) {
    //Does the list contain the given element?
    //Return true if so, false otherwise.
    if (find(element) == null) {
        return false;
    }
    else {
        return true;
    }
}

public boolean remove(T element) {
    //While the list is not empty, curr will move down. If the element can not
    //be found, then return false. Else remove the element.
    DLLNode<T> curr;
    curr = front;
    T currInfo = curr.getInfo();
    while(curr != null) {   
        curr = (DLLNode<T>)curr.getLink();      
    }
    if (find(element) == null) {
        return false;
    }
    else {
        if (curr == null) {
            curr = curr.getBack();
            curr = rear;
        }
        else if (curr == front) {
            curr = (DLLNode<T>)curr.getLink();
            curr = front;
        }
        else if (curr == rear) {
            curr = curr.getBack();
            curr = rear;
        }
        else {

        }
    return true;
    }
}   

public T get(T element) {
    //Return the info of the find method.
    if (find(element) == null) {
        return null;
    }
    else {
        return find(element).getInfo();
    }

}

//public String toString() {

//}

public void reset() {
    //Reset the iteration back to front
    curPosition = front;        
}

public T getNext() {
    //Return the info of the next element in the list
    DLLNode<T> curr;
    curr = front;
    //while (curr != null) {
        //curr = (DLLNode<T>)curr.getLink();
    //}
    if ((DLLNode<T>)curr.getLink() == null) {
        return null;
    }   
    else {
        curr = (DLLNode<T>)curr.getLink();
        return curr.getInfo();
    }       
}

public void resetBack() {

}

public T getPrevious() {
    //Return the previous element in the list
    DLLNode<T> curr;
    curr = front;
    if ((DLLNode<T>)curr.getLink() == null) {
        return null;
    }
    else if((DLLNode<T>)curr.getBack() == null) {
        return null;
    }
    else {
        curr = curr.getBack();
        return curr.getInfo();
    }
}

public void add(T element) {
    //PreCondition: Assume the element is NOT already in the list
    //AND that the list is not full!
    DLLNode<T> curr;                
    DLLNode<T>  newNode = (DLLNode<T>)element;
    curr = front;
    if (curr == null) {
        front = (DLLNode<T>)element;
    }
    else {

    }

  }
}

public类双重实现ListInterface{
受保护的DLLNode前端；//列表的前端
受保护的DLLNode后方；//列表后方
受保护的DLLNode curPosition；//迭代的当前点
受保护的整数；//列表中的元素数
公共双（）{
front=null；
后=空；
curPosition=null；
数值=0；
}
受保护的DLLNode查找（T目标）{
//当列表不为空且目标不等于当前元素时
//curr将在列表中向下移动。如果curr变为null，则返回null。
//如果找到元素，则返回它。
dllnodecurr；
curr=正面；
T currInfo=curr.getInfo（）；
while（curr！=null&&currInfo.compareTo（target）！=0）{
curr=（DLLNode）curr.getLink（）；
}
if（curr==null）{
返回null；
}
否则{
返回货币；
}           
}
公共整数大小（）{
//返回列表中的元素数
回礼；
}
公共布尔包含（T元素）{
//列表是否包含给定的元素？
//如果是，则返回true，否则返回false。
if（查找（元素）==null）{
返回false；
}
否则{
返回true；
}
}
公共布尔删除（T元素）{
//当列表不为空时，curr将下移。如果元素不能
//，然后返回false。否则，请删除该元素。
dllnodecurr；
curr=正面；
T currInfo=curr.getInfo（）；
while（curr！=null）{
curr=（DLLNode）curr.getLink（）；
}
if（查找（元素）==null）{
返回false；
}
否则{
if（curr==null）{
curr=curr.getBack（）；
电流=后部；
}
否则如果（当前==前）{
curr=（DLLNode）curr.getLink（）；
curr=正面；
}
否则如果（当前==后）{
curr=curr.getBack（）；
电流=后部；
}
否则{
}
返回true；
}
}   
公共T获取（T元素）{
//返回find方法的信息。
if（查找（元素）==null）{
返回null；
}
否则{
返回find（element.getInfo（）；
}
}
//公共字符串toString（）{
//}
公共无效重置（）{
//将迭代重置回前端
curPosition=前面；
}
公共T getNext（）{
//返回列表中下一个元素的信息
dllnodecurr；
curr=正面；
//while（curr！=null）{
//curr=（DLLNode）curr.getLink（）；
//}
if（（DLLNode）curr.getLink（）==null）{
返回null；
}   
否则{
curr=（DLLNode）curr.getLink（）；
返回当前getInfo（）；
}       
}
公共无效重置回（）{
}
公共T getPrevious（）{
//返回列表中的上一个元素
dllnodecurr；
curr=正面；
if（（DLLNode）curr.getLink（）==null）{
返回null；
}
else如果（（DLLNode）curr.getBack（）==null）{
返回null；
}
否则{
curr=curr.getBack（）；
返回当前getInfo（）；
}
}
公共无效添加（T元素）{
//前提条件：假设元素不在列表中
//而且名单还没有满！
dllnodecurr；
DLLNode newNode=（DLLNode）元素；
curr=正面；
if（curr==null）{
前=（DLLNode）元素；
}
否则{
}
}
}

这是最终的目标主要功能：

public static void main(String[] args){

 Double<String> d = new Double<String>();
 d.add("Hello");
 d.add("Arthur");
 d.add("Goodbye");
 d.add("Zoo");
 d.add("Computer Science");
 d.add("Mathematics");
 d.add("Testing");

 System.out.println(d);

 System.out.println( "Contains -Hello- " + d.contains("Hello"));
 System.out.println("Contains -Spring- " + d.contains("Spring"));
 System.out.println("size: " + d.size());
 d.resetBack();
 for (int i = 0; i < d.size(); i++){
    String item = (String)d.getPrevious();
    System.out.println(item);
  } //good stopping point
 d.remove("Zoo");
 d.remove("Arthur");
 d.remove("Testing"); 
 System.out.println("size: " + d.size()); 
 System.out.println(d);
 d.remove("Goodbye");
 d.remove("Hello");
 System.out.println(d);
 d.remove ("Computer Science");
 d.remove("Mathematics");
 System.out.println(d);}
 }  

publicstaticvoidmain（字符串[]args）{
双d=新的双d（）；
d、 加上（“你好”）；
d、 添加（“亚瑟”）；
d、 加上（“再见”）；
d、 添加（“动物园”）；
d、 加上（“计算机科学”）；
d、 加上（“数学”）；
d、 添加（“测试”）；
系统输出打印ln（d）；
System.out.println（“Contains-Hello-”+d.Contains（“Hello”）；
System.out.println（“Contains-Spring-”+d.Contains（“Spring”））；
System.out.println（“大小：+d.size（））；
d、 复位（）；
对于（int i=0；i

我不知道您的

DLLNode

类看起来像什么，但它可能看起来像什么

class DLLNode {
    DLLNode next;
    DLLNode prev;
}

要删除节点，逻辑将是

next.prev = prev;
prev.next = next;

要在节点之后添加节点

newNode

，逻辑如下

newNode.prev = this;
newNode.next = next;
next = newNode;

---

我没有做任何空指针检查，这取决于您。

是的，我发现了一些让我尝试的东西。我现在在让我的toString开始工作时遇到了一些问题。在toString工作之后，我将能够查看我的添加/删除是否工作