Java 双链接列表-头正在更改，而我没有更改它

问题在于DLinkedList类中的findA方法。 这个方法显然改变了我的想法。下一个指向tmp。下一个 我创建了一个列表{0,1,2,3,4,5,6,7,8,9} 我曾经

芬达（9）

我的列表缩小到{9}，尽管函数给出正确的结果，不管给定的值是否在我的列表中（true或false）

另一方面，我的find方法工作得很好，两者之间的唯一区别是我在findA中使用了Node tmp=head 和节点tmp=head.next in find

下面是完整的代码片段。我意识到有些实现非常不专业。如对此有任何评论，将不胜感激

public class Node <T extends Comparable<T>> {
T data;
Node prev;
Node next;

Node(){
}

Node(T val){
    data = val;
}  }

public class DLinkedList<T extends Comparable<T>> {
Node head;
Node tail;

DLinkedList(){
    head = new Node();    
    tail = new Node();
    tail.prev = head;
}

void insertInOrder(T value){
    Node insert = new Node(value);
    if(head.next==null){
        head.next = insert;
        insert.prev = head;
        insert.next = tail;
        tail.prev = insert;
    }
    else{
        insert.prev = tail.prev;
        tail.prev.next = insert;
        tail.prev = insert;
        insert.next = tail;
    }
}

boolean find (T value){
    boolean result = false;
    Node tmp = head.next;
    if (head!=null){
        while(tmp!=null){
            if(tmp.data.compareTo(value)!=0){
                tmp = tmp.next;
            }
            else{
                result = true;
                break;
            }
        }
    }
    return result;
}

 boolean findA (T value){
    boolean result = false;
    Node tmp = head;
    if (head!=null){
        while(tmp.next!=null){
            if(tmp.next.data.compareTo(value)!=0){
                tmp.next = tmp.next.next;
            }
            else{
                result = true;
                break;
            }
        }
    }
    return result;
}

void deleteA(T value){
    Node tmp = head.next;

    while(tmp.data.compareTo(value)!=0){
            tmp = tmp.next;
    }
    if(tmp!=tail){
        if(tmp==head.next)
            head = tmp.next;
        else
             tmp.prev.next = tmp.next;

        if (tmp==tail)
            tail = tmp.prev;
        else
            tmp.next.prev = tmp.prev;
    }






}
void delete(T value){
    Node tmp = head.next;
    if(find(value)){
        while(tmp!=tail){
            if(tmp.data.compareTo(value)!=0){
                tmp = tmp.next;
            }
            else{
                tmp.prev.next = tmp.next;
                tmp.next.prev = tmp.prev;

                break;
            }
        }            
    }
}

@Override
public String toString(){
    Node tmp = head.next;
    String result = "";
        while(tmp!=tail){
            System.out.println(tmp.data);
            tmp = tmp.next;
        }
    return result;
}  }

public class ListCheck {

public static void main(String[] args) {
    DLinkedList list = new DLinkedList();
    DLinkedList listA = new DLinkedList();
    for(int i=0; i<10; i++){
        list.insertInOrder(i);
        listA.insertInOrder(i);
    }
    System.out.println(listA.findA(9));
    System.out.println(list.find(9));  
    listA.toString();
    System.out.println("");
    list.toString();
} }

公共类节点{
T数据；
节点前置；
节点下一步；
节点（）{
}
节点（T值）{
数据=val；
}  }
公共类DLinkedList{
节点头；
节尾；
DLinkedList（）{
头=新节点（）；
tail=新节点（）；
tail.prev=头部；
}
无效插入器（T值）{
节点插入=新节点（值）；
if（head.next==null）{
head.next=插入；
insert.prev=头部；
insert.next=尾部；
tail.prev=插入；
}
否则{
insert.prev=tail.prev；
tail.prev.next=插入；
tail.prev=插入；
insert.next=尾部；
}
}
布尔查找（T值）{
布尔结果=假；
节点tmp=head.next；
if（head！=null）{
while（tmp！=null）{
如果（tmp.data.compareTo（值）！=0）{
tmp=tmp.next；
}
否则{
结果=真；
打破
}
}
}
返回结果；
}
布尔findA（T值）{
布尔结果=假；
节点tmp=头部；
if（head！=null）{
while（tmp.next！=null）{
if（tmp.next.data.compareTo（值）！=0）{
tmp.next=tmp.next.next；
}
否则{
结果=真；
打破
}
}
}
返回结果；
}
无效删除A（T值）{
节点tmp=head.next；
而（tmp.data.compareTo（值）！=0）{
tmp=tmp.next；
}
如果（tmp！=尾部）{
if（tmp==head.next）
head=tmp.next；
其他的
tmp.prev.next=tmp.next；
如果（tmp==尾部）
tail=tmp.prev；
其他的
tmp.next.prev=tmp.prev；
}
}
无效删除（T值）{
节点tmp=head.next；
如果（查找（值））{
while（tmp！=尾部）{
如果（tmp.data.compareTo（值）！=0）{
tmp=tmp.next；
}
否则{
tmp.prev.next=tmp.next；
tmp.next.prev=tmp.prev；
打破
}
}            
}
}
@凌驾
公共字符串toString（）{
节点tmp=head.next；
字符串结果=”；
while（tmp！=尾部）{
系统输出打印LN（tmp数据）；
tmp=tmp.next；
}
返回结果；
}  }
公共类列表检查{
公共静态void main（字符串[]args）{
DLinkedList=新的DLinkedList（）；
DLinkedList listA=新的DLinkedList（）；
对于findA中的（inti=0；i，移动tmp的方式是

tmp.next = temp.next.next

这样，您将销毁当前指针并将其重新路由到下一个节点（java的浅层副本）：

tmp-->[node1]-->[node2]
更改为
tmp-->[node2]

因此，在操作结束时，linkedlist只剩下最后一个节点

将其更改为
tmp=tmp。接下来
将有助于
在findA中，移动tmp的方式是

tmp.next = temp.next.next

这样，您将销毁当前指针并将其重新路由到下一个节点（java的浅层副本）：

tmp-->[node1]-->[node2]
更改为
tmp-->[node2]

因此，在操作结束时，linkedlist只剩下最后一个节点

将其更改为
tmp=tmp。next
将有助于您更改
tmp。next
而不是
tmp
？还有谁在乎head是否为null或
tmp
是否为
tail
。只需从head循环，直到它为null。@CollinD，因为我以head的身份启动了我的tmp，而我的head通过design不存储数据是，而更改
tmp。next
将更改
头部。next
因为
next
是一个引用。为什么要更改
tmp。next
而不是
tmp
？还有谁在乎头部是null还是
tmp
是
尾部。只要从头部循环，直到它为null。@CollinD，因为我启动了tmp作为头部，而我的头部没有按设计存储任何数据es和更改
tmp.next
将更改
head.next
，因为
next
是一个参考。