在排序的链表中查找重复项

Question

我已经创建了一个排序的链表，现在我正试图弄清楚如何删除重复项。我想在我创建的 Add 方法中添加可以执行此操作的代码，但我似乎无法弄清楚。我觉得这应该相对容易，但我现在有点脑死了。

在我的 add 方法中，我检查索引以查看要添加项目的位置。 “Index”是一个 int 变量，但我想检查“item”（一个可比较的）是否与之前存储的相同项目。我想使用 compareTo 方法，但我会得到类型不匹配。有没有人知道更好的方法来做到这一点？

这是我的 add 方法的代码：

 package sortedListReferenceBased;

     public class SortedListReferenceBasedIterativeNoDuplicates
     implements SortedListInterface {

     // reference to linked list of items
     private Node head; 
     private int numItems; // number of items in list

     public SortedListReferenceBasedIterativeNoDuplicates() {
     numItems = 0;
     head = null;
     }  // end default constructor

      public boolean sortedIsEmpty() {
        return numItems == 0;
      //TODO
     }  // end sortedIsEmpty

     public int sortedSize() {
  return numItems;
      //TODO
     }  // end sortedSize

      private Node find(int index) {
     // --------------------------------------------------
     // Locates a specified node in a linked list.
     // Precondition: index is the number of the desired
    // node. Assumes that 1 <= index <= numItems+1
    // Postcondition: Returns a reference to the desired 
   // node.
  // --------------------------------------------------
  Node curr = head;
  for (int skip = 1; skip < index; skip++) {
   curr = curr.getNext();
} // end for
return curr;
  } // end find


  public Comparable sortedGet(int index) 
                throws ListIndexOutOfBoundsException {
      if (index >= 1 && index <= numItems){
          Node curr = find(index);
          Object dataItem = curr.getItem();
          return (Comparable) dataItem;
      }
      else {
          throw new ListIndexOutOfBoundsException("List index out of bounds on   get.");
  }
    //TODO
  } // end sortedGet()


  public void sortedAdd(Comparable item) throws ListException{ 
   int index = locateIndex(item); //to find location where item should be added
   if( index >=1 && index <= numItems+1){
       //if adding an item to the very beginning of list
       if (index == 1){
           Node newNode = new Node(item,head);
           head = newNode;
       }
       if (item.compareTo(something something?)== 0){ //if item is a duplicate of previous item do nothing
           System.out.println("No duplicates!");
       }

       //advances 
       else {
           Node prev = find(index-1); //finds out where previous node is
           Node newNode = new Node(item, prev.getNext()); //creates Node with item you wish to add
           prev.setNext(newNode); //links new node with previous node
          }
          numItems++;  
      }//end main if statement
      else {
           throw new ListIndexOutOfBoundsException("List index out of bounds on add.");
      }
    //TODO
  }  // end sortedAdd()


  public void sortedRemove(Comparable item) throws ListException {
      int index = locateIndex(item);
      if (index >= 1 && index <= numItems){ //if the index is greater than 1 (meaning list not empty) and
                                              //index doesn't exceed list size do the following:
      //if index is value of one then delete first node in this special way
      if (index == 1) {
          head = head.getNext();
      }
    //if there is only one item in the list then set head to nothing so index out of bounds error won't occur
      if (numItems == 1){
          head = null;
      }
      else { //if none of these things occur go ahead and delete item, allocating Nodes accordingly
          Node prev = find(index-1);
          Node curr = prev.getNext();
          prev.setNext(curr.getNext());
      }
      numItems--;//must account for one less item
      }
  if (!sortedIsEmpty()){
      System.out.println("Item does not exist!");
  }
  else { //if index doesn't meet if statement requirements 
      throw new ListIndexOutOfBoundsException("List index out of bounds on remove.");
  }

//TODO
 } // end sortedRemove


 public void sortedRemoveAll() {
   // setting head to null causes list to be
   // unreachable and thus marked for garbage 
   // collection
   head = null;
   numItems = 0;
 } // end sortedRemoveAll


 //Returns the position where item belongs or exists in a sorted list;
 //item and the list are unchanged.
 public int locateIndex(Comparable item) {
     Node curr = head;
     for (int i = 1; i <= sortedSize(); i++){
         if (item.compareTo(curr.getItem())<= 0){
            return i;
        }//end if

         else {
             curr = curr.getNext();
         }//end else
     }//end for
     return sortedSize()+1; 
    //TODO
 } //end locateIndex()




} // end ListReferenceBased

对于奇怪的格式，我深表歉意。现在还蛮坎坷的。如果这个问题真的很明显，我也很抱歉！哈哈

Answer 1

初步要点：

1. 我不明白为什么您似乎在尝试在 Java 中实现链表...鉴于 java.util.LinkedList 形式的实现已经非常好。

2. 没有重复的集合是一个集合...

3. 基于链表的集合将是次优的。例如，插入是O(N)，而O(logN) 是基于树的实现，O(1) 是基于哈希表的实现（假设它的大小合适）。 java.util.TreeSet 和 java.util.HashSet 分别是示例。

话虽如此，并假设您确实想要洞察力/提示......

如果您有一个预排序的链表，那么删除重复项的方法是逐步遍历节点，将node.value 与node.next.value 进行比较。如果值相等，则您找到了重复项，您可以通过将node.next 更改为node.next.next 将其删除。您的代码还需要处理各种“边缘情况”；例如包含 0 或 1 个元素等的列表。

Answer 2

您是否打算使用链表？使用内置的TreeSet 似乎更适合这种情况。

Answer 3

试试

if (locateIndex(item) != (sortedSize() + 1)) { //locateIndex returns sortedSize() + 1 if it didn't find the item, so we check that

    System.out.println("No duplicates!");
}

这都是关于使用您已经编写的代码。