从链表中删除元素java

Question

嗨:)我有一个关于链表的程序，我们应该能够删除两个数字，如果它们是相同的..我知道如何从一开始就做到这一点，但如何如果它们位于链表的中间，你会删除两个数字吗？所有3一起奔跑 我的继承人数字节目

import java.util.Scanner; 

public class Numbers { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     Scanner reader = new Scanner (System.in); 
     LinkedList link=new LinkedList(); 
     LinkedList link2= new LinkedList(); 
     System.out.println("Enter in 5 numbers to put in your list"); 
     int num1, num2, num3, num4, num5; 
     num1 = reader.nextInt(); 
     link.addToStart(num1); 
     num2 = reader.nextInt(); 
     link.addToStart(num2); 
     num3 = reader.nextInt(); 
     link.addToStart(num3); 
     num4 = reader.nextInt(); 
     link.addToStart(num4); 
     num5 = reader.nextInt(); 
     link.addToStart(num5); 

     link2.addToStart(num5); 
     link2.addToStart(num4); 
     link2.addToStart(num3); 
     link2.addToStart(num2); 
     link2.addToStart(num1); 

     System.out.println("The size of the linked list is " + link.size()); 

     System.out.print("Here is the list "); 
     link2.outputList(); 
     System.out.println(); 
     System.out.print("Here is the list in reverse order "); 
     link.outputList(); 
     System.out.println(); 

     if (num1==num2){ 
      link2.deleteHeadNode(num1); 
      link2.deleteHeadNode(num2); 
      System.out.println("Here is the list with the removed numbers"); 
      link2.outputList(); 
      System.out.println(); 
      System.out.println("Here is its size"); 
      System.out.println(link2.size()); 
     } 
     else if (num2==num3){ 
      link2.deleteHeadNode(num2); 
      link2.deleteHeadNode(num3); 
      System.out.println("Here is the list with the removed numbers"); 
      link2.outputList(); 
      System.out.println(); 
      System.out.println("Here is its size"); 
      System.out.println(link2.size()); 
     } 
    } 

} 

这里是节点程序

public class Node1 
{ 
    private Object item; 
    private int count; 
    private Node1 link; 

    public Node1() 
    { 
     link = null; 
     item = null; 
     count = 0; 
    } 

    public Node1(int num, int newCount, Node1 linkValue) 
    { 
     setData(num, newCount); 
     link = linkValue; 
    } 

    public void setData(int num, int newCount) 
    { 
     item = num; 
     count = newCount; 
    } 

    public void setLink(Node1 newLink) 
    { 
     link = newLink; 
    } 

    public Object getItem() 
    { 
     return item; 
    } 

    public int getCount() 
    { 
     return count; 
    } 

    public Node1 getLink() 
    { 
     return link; 
    } 
} 

，这里是链表编程

public class LinkedList 
{ 
    private Node1 head; 

    public LinkedList() 
    { 
     head = null; 
    } 

    /** 
    Adds a node at the start of the list with the specified data. 
    The added node will be the first node in the list. 
    */ 
    public void addToStart(int num) 
    { 
     head = new Node1(num, num, head); 
    } 

    /** 
    Removes the head node and returns true if the list contains at least 
    one node. Returns false if the list is empty. 
    * @param num1 
    */ 
    public boolean deleteHeadNode(int num1) 
    { 
     if (head != null) 
     { 
      head = head.getLink(); 
      return true; 
     } 
     else 
      return false; 
    } 

    /** 
    Returns the number of nodes in the list. 
    */ 
    public int size() 
    { 
     int count = 0; 
     Node1 position = head; 

     while (position != null) 
     { 
      count++; 
      position = position.getLink(); 
     } 
     return count; 
    } 

    public boolean contains(String item) 
    { 
     return (find(item) != null); 
    } 

    /** 
    Finds the first node containing the target item, and returns a 
    reference to that node. If target is not in the list, null is returned. 
    */ 
    private Node1 find(String target) 
    { 
     Node1 position = head; 
     Object itemAtPosition; 
     while (position != null) 
     { 
      itemAtPosition = position.getItem(); 
      if (itemAtPosition.equals(target)) 
       return position; 
      position = position.getLink(); 
     } 
     return null; //target was not found 
    } 

    public void outputList() 
    { 
     Node1 position = head; 
     while (position != null) 
     { 
      System.out.print(position.getItem() + " "); 
      position = position.getLink(); 
     } 
    } 

    public boolean isEmpty() 
    { 
     return (head == null); 
    } 

    public void clear() 
    { 
     head = null; 
    } 

} 

Answer 1

要的中间删除项目链接“列表中，将前一项目的”链接“指针设置为要删除的对象的”链接“指针。例如，您可以添加这样的事情您的LinkedList类：

public void removeNode(Node previousNode, Node nodeToRemove) { 
    if (previousNode != null) { 
    previousNode.setLink(nodeToRemove.getLink()); 
    } 
} 

思考这个好，画一幅画。

N1 -> N2 -> N3 -> N4 

N1的“链接”是N2等。如果您想删除N2，只需将N1的“链接”设置为N3即可。

N1 -> N3 -> N4 

Answer 2

一种方法来执行暴力查找。

• 对于搜索的每个元素，如果在列表中重复。
• 如果是这样，你删除它
• 并与下一个去。

正如你可能看到这三个步骤可能很容易编码，这里的重点是要先了解他们是否按照你的意愿去做。

这是这三个点的伪代码：

forEach(Element a : inList) do 
    // e is the element we want to find repeated. 
    forEach(Element b : inList) do 
     // b is the element in the list. 
     if(a == b) then // repeated 
      inList.remove(a) 
      break; 
     endIf 
    endFor 
endFor 

这种方法可以让你删除所有重复的元素。

只记得删除一个项目，你必须确保你不会失去它的参考。所以，如果您有：

n1 -> n2 -> n3 

在某些时候你必须有n1和n2指向n3（方式N1，保持基准N2具有）

n1 -> n3 n2 ->n3 

然后取出N2留下您：

n1 -> n3 

现在如何与您的特定数据结构代码，你必须执行任务;）

Answer 3

这是一种方法。

public void delete(int item) 
{ 
     while(head.data==item)    //For deleting head 
    { 

     head=head.link; 

    } 
    // For middle elements.................. 
    Node ptr, save; 
    save=head; 
    ptr=head.link; 
    while(ptr!=null) 
    { 
     if(ptr.data==item) 
     { 
     Node next=ptr.link; 
     save.link=next; 
     ptr=next; 
     } 
     else 
     { 
      save=ptr; 
      ptr=ptr.link; 
     } 

} 
}