从 `LinkedList` 中删除指定的 `Link`答案

【问题标题】：Deleting a specified `Link` from `LinkedList`从 `LinkedList` 中删除指定的 `Link`
【发布时间】：2015-07-27 23:22:48
【问题描述】：

伙计们，我无法从 LinkedList 中删除指定的 Link。例如，如果我有：

"A" --> "B" --> "C"

并且想删除Link "B"，所以结果是：

"A" --> "C"

我在获取以前的Link "A" 和引用"C" 时遇到了麻烦。谁能帮我解决这个问题？方法是：

 public void delete(String data){
        if(isEmpty()){
            System.out.println("The list is empty!");
            System.exit(0);
        }
        else{
            Link current = firstLink;
            Link previous = firstLink;
            while(current != null){
                if(current.getData().equals(data)){
                    previous = current.getNext();   
                }
                else{
                    previous = current;
                    current = current.getNext();
                }
            }
        }
    }

班级Link

package LinkedList;

public class Link{

    private String data;
    private Link next;

    public Link(String data){
        this.data = data;
    }

    public void display(){
        System.out.println(data);
    }

    public String getData(){
        return this.data;
    }

    public Link getNext(){
        return this.next;
    }
}

class LinkedList{

    private Link firstLink;

    public LinkedList(){
        this.firstLink = null;
    }

    public boolean isEmpty(){
        return (this.firstLink == null);
    }

    public void insert(String data){
        Link newLink = new Link(data);
        Link newLinkNext = newLink.getNext();
        newLinkNext = firstLink;
        firstLink = newLink;
    }

    public Link deleteFirst(){
        if(isEmpty()){
            return null;
        }
        else {
            Link deletedOne = this.firstLink;
            Link nextLink = firstLink.getNext();
            firstLink = nextLink;
            return deletedOne;
        }
    }

    public void delete(String data){
    if(isEmpty()){
        System.out.println("The list is empty!");
        System.exit(0);
    }
    else{
        Link current = firstLink;
        Link previous = firstLink;
        while(current != null){
            if(current.getData().equals(data)){
                previous = current.getNext();   
            }
            else{
                previous = current;
                current = current.getNext();
            }
        }
    }
}

【问题讨论】：

我什至没有看到任何将 A 加入 C 的尝试。您需要知道 B 之前的节点，以便您可以使 B 之前的节点指向 B 之后的节点...
@John3136，这是我的问题，我应该如何在"B" 之前获得节点？
您有一个while 循环 - 为什么每次循环时不记住前一个值？
@John3136，我已经更新了代码。尚未测试，但将在几秒钟内完成
应该是previous.next = current.getNext() 而不是previous = current.getNext()。可能应该检查current == firstLink 并适当处理。

标签： java linked-list nodes

【解决方案1】：

伪代码：

prev = null;
current = first;
while not at the end of the list
{
    if (current.data == the object I want) {
        if (prev == null) {
            first = current.next
            break
        }
        prev.next = current.next
        break;
    }
    prev = current
    current = current.next
}

【讨论】：

问题，@John3136，你为什么会有prev.next = current.next？
它将前一个节点设置为指向下一个节点（所以现在“当前”不是您列表的一部分）。它在 if 中，所以只有在 current 是您要删除的节点时才这样做。
但还是不行，@John3136。我已经尝试过您在此处提供的代码
然后您需要发布更多详细信息 - 伪代码有效 - 用笔和纸检查它以确认 - 这可能有助于您发现问题。

【解决方案2】：

这是一个试图使其与您的代码相似的示例

public class LinkedList {

private Node firstNode = null;

public LinkedList() {
}

public Node getFirstNode() {
    return firstNode;
}

public void setFirstNode(Node firstNode) {
    this.firstNode = firstNode;
}

public void addNode(Node node) {
    if(firstNode == null){
        firstNode = node;
    }else{
        Node walker = firstNode;
        while(walker.getNext() != null)
            walker = walker.getNext();
        walker.setNext(node);
    }
}

public void delete(int value) {
    if (firstNode != null) {
        Node walker = firstNode;
        if (walker.getValue() == value) {
            if(walker.getNext()!=null){
                firstNode = walker.getNext();
            }else{
                setFirstNode(null);
            }
        } else {
            Node previous = walker;
            while (walker.getNext() != null) {
                previous = walker;
                walker = walker.getNext();
                if (walker.getValue() == value) {
                    previous.setNext(walker.getNext());
                    break;
                }
            }
        }

    } else {
        System.out.println("Nothing to delete");
    }
}

public void listValues (){
    if(firstNode != null){
        Node walker = firstNode;
        while(walker.getNext() != null)
        {
            System.out.println(walker.getValue());
            walker = walker.getNext();

        }
    }
}

}

公共类节点{

private Node next = null;
private int value;

public Node(Node node, int value) {
    this.next = node;
    this.value = value;
}

public Node getNext() {
    return next;
}

public void setNext(Node node) {
    this.next = node;
}

public int getValue() {
    return value;
}

public void setValue(int value) {
    this.value = value;
}

}

公共类模拟{

public static void main(String[] args) {
    LinkedList list = new LinkedList();
    list.addNode(new Node(null, 1));
    list.addNode(new Node(null, 2));
    list.addNode(new Node(null, 3));
    list.addNode(new Node(null, 4));
    list.addNode(new Node(null, 123));
    list.addNode(new Node(null, 5));
    list.addNode(new Node(null, 6));
    list.listValues();


    list.delete(1);
    System.out.println("-----");
    list.listValues();

    list.delete(123);
    System.out.println("-----");
    list.listValues();


    list.addNode(new Node(null, 123));
    list.addNode(new Node(null, 5));

    list.delete(2);
    System.out.println("-----");
    list.listValues();

    list.delete(26);
    System.out.println("-----");
    list.listValues();
}

}

和输出：1 2 3 4 123 5

2 3 4 123 5

2 3 4 5

3 4 5 6 123

问候

【讨论】：

【解决方案3】：

class LLNode
    {
        int data;
        LLNode next;
        public LLNode(int data)
        {
            this.data=data;
        }
    }

public class DeleteNodeFromLinkedList 
{
    /* Link list node */


    /* Given a reference (pointer to pointer) to the head
    of a list and an int, push a new node on the front
    of the list. */

    public static void printList(LLNode head)
    {
       LLNode curr = head;
       while(curr != null)
       {
          System.out.print(curr.data+" ");
          curr = curr.next;
       }
    }

    static void deleteNode(LLNode DelNode)
    {
       LLNode temp = DelNode.next;
       DelNode.data = temp.data;
       DelNode.next = temp.next;

    }

    /* Drier program to test above function*/
    public static void main(String []args)
    {
        /* Start with the empty list */
        LLNode head = new LLNode(1);
        head.next = new LLNode(4);
        head.next.next = new LLNode(4);
        head.next.next.next = new LLNode(1);
        head.next.next.next.next = new LLNode(12);
        head.next.next.next.next.next = new LLNode(1);


        System.out.println(" Before deleting ");
        printList(head);

        /* I m deleting the head.next
            You can check for more cases */
       deleteNode(head.next);

       System.out.println(" \n After deleting ");
       printList(head);

    }
}

【讨论】：

【解决方案4】：

当您对列表进行迭代时，您不能在列表中进行操作（添加、删除...项目）。您必须使用迭代器

 for(Iterator<EmpDedup> iter = list.iterator(); iter.hasNext();) {
     EmpDedup data = iter.next();
     if (data.getRecord() == rec1) {
         iter.remove();
     }
  }

见http://docs.oracle.com/javase/6/docs/api/java/util/Iterator.html

【讨论】：