Question

我在java中编写自己的链表，它是泛型类型，而不是使用java集合链表。链表的add方法由以下代码组成：

public void add(T item, int position) {
  Node<T> addThis = new Node<T>(item);
  Node<T> prev = head;
  int i;

  if(position <= 0) {
    System.out.println("Error: Cannot add element before position 1.");
  }

  else if(position == 1) {
    addThis.setNext(head);
    head = addThis;
  } else {
    for(i = 1; i < position-1; i++) {
      prev = prev.getNext();
      if(prev == null) {
        System.out.println("Cannot add beyond end of list");
      }
    } // end for
    addThis.setNext(prev.getNext());
    prev.setNext(addThis);
  }
} // end add

我如何制作它以便在添加新项目时将该项目与另一项目进行比较并按字母顺序插入？我已经研究过使用compareTo，但我无法弄清楚如何做到这一点。

由于

编辑：我有各种类：我有一个名为Dvd的类，它有标题（字符串）的方法和变量以及该标题的副本数（int）。我还有linked list class，listinterface，node class和main class。

Answer 1

你提到使用泛型但后来提到按字母顺序排序。泛型不一定是字符串，它们用于表示任何类型，而排序属性（如字母顺序）表示字母字符。我的答案假设您期望T类型的通用对象具有字母性质。在我的示例中，我专门使用String

您可以设置代码以搜索要添加的位置，而不是提供它。

public void add(T item) {
    Node<T> addThis = new Node<T>(item);
    Node<T> itr = head;

    while (itr.hasNext()) {
        if (addThis.compareTo(itr.getNext()) <= 0) { // itr > addThis
            addThis.setNext(itr.getNext());
            itr.setNext(addThis);
            return;
        }
        itr = itr.getNext();
    }
    addThis.setNext(null);
    itr.setNext(addThis);
    return;
} // end add

然后在Node课程中，您可以实施Interface Comparable。我假设你存储了一个字符串，因为你询问了字母顺序。 This Question解释按字母顺序比较字符串。

class Node implements Comparable<Node> {


    String value;  // ASSUMING YOU ARE USING A STRING AS YOUR GENERIC TYPE T

    @Override
    public int compareTo(Node otherNode) {
        int i;
        String thisString = this.getValue();
        String otherString = otherNode.getValue();
        int minSize = ( otherString.length() > thisString.length() ? thisString.length() : otherString.length() );
        for (i = 0; i < minSize; i++) {
             if (thisString.charAt(i) > otherString.charAt(i)) {
                 return 1;
             } else if (thisString.charAt(i) < otherString.charAt(i)) {
                 return -1;
             }
        }
        if (otherString.length() > thisString.length()) {
            return 1;
        } else if (otherString.length() < thisString.length()) {
            return -1;
        } else {
            return 0;
        }
    }

    // OTHER CLASS CONSTRUCTORS, VARIABLES, AND METHODS
}

为了通过简单的泛型来实现这一点，您需要实现Node类，其类型T实现Comparable，如下所示：

class NodeNode<T extends Comparable<T>> implements Comparable {


    T value;

    @Override
    public int compareTo(Node otherNode) {
        return this.getValue().compareTo(otherNode.getValue());
    }

    // OTHER CLASS CONSTRUCTORS, VARIABLES, AND METHODS
}

Answer 2

您的实现是否扩展了java.util.List接口？

您可以简单地将对象添加到列表中，然后使用Collections.sort（）？

对列表进行排序

Answer 3

我终于通过使用插入排序来解决这个问题：

public void add(Dvd item) {
  DvdNode addThis = new DvdNode(item);
  if(head == null) {
    head = addThis;
  } else if(item.getTitle().compareToIgnoreCase(head.getItem().getTitle()) < 0) {
      addThis.setNext(head);
      head = addThis;
    } else {
        DvdNode temp;
        DvdNode prev;
        temp = head.getNext();
        prev = head;
        while(prev.getNext() != null && item.getTitle().compareToIgnoreCase
            (prev.getNext().getItem().getTitle()) > 0) {
          prev = temp;
          temp = temp.getNext();
        }
        addThis.setNext(temp);
        prev.setNext(addThis);
      }
}

如何在Java中自定义泛型类型链表？

3 个答案: