Question

对于家庭作业，我需要实现自己的PriorityQueue和PriorityQueueSort。我使用泛型来使它在没有排序功能的情况下工作，但现在我被困在这里..

public static void PriorityQueueSort(Iterable<?> list, 
    PriorityQueue<?,?> pq) {
  if (!pq.isEmpty()) {
    throw new IllegalArgumentException("Non-Empty PriorityQueue");
  }

  for (Object obj : list) {

  }
}

我需要传入一个列表和一个空的PriorityQueue，所以我最好猜测如何做到这一点就在上面。我应该如何攻击这个以便我可以迭代未知类型的列表，并将具有正确类型的列表中的每个元素添加到优先级队列中？

编辑：

以下是一些细节，因为我们确定没有提供足够的信息。

我有一个自定义的PriorityQueue类，以及一个自定义的Entry类，它包含一个K类型的键，以及一个V类型的值。

我需要能够使用任何类型T获取任何可迭代列表并迭代它，获取每个项目并将其添加到最初为空的PriorityQueue作为具有空值的键。然后我需要在我的PriorityQueue上连续调用removeMin（）并将它按顺序添加回相同的列表对象。

public class PriorityQueue<K extends Comparable<? super K>,V> {

  private Entry<K,V> _head;
  private Entry<K,V> _tail;
  private int _size;

  public PriorityQueue() {
    this._head = null;
    this._tail = null;
    this._size = 0;
  }

  public int size() {
    return _size;
  }

  public boolean isEmpty() {
    return (size() == 0);
  }

  public Entry<K,V> min() {
    if (_head == null) {
      return null;
    }
    Entry<K,V> current = _head;
    Entry<K,V> min = _head;;

    while (current != null) {
      if (current.compareTo(min) < 0) {
        min = current;
      }
      current = current.getNext();
    }
    return min;
  }

  public Entry<K,V> insert(K k, V x) {
    Entry<K,V> temp = new Entry<K,V>(k,x);
    if (_tail == null) {
      _tail = temp;
      _head = temp;
    }
    else {
      _tail.setNext(temp);
      temp.setPrev(_tail);
      _tail = temp;
    }
    return temp;
  }

  public Entry<K,V> removeMin() {
    Entry<K,V> smallest = min();
    smallest.getPrev().setNext(smallest.getNext());
    smallest.getNext().setPrev(smallest.getPrev());

    return smallest;
  }

  public String toString() {
    return null;
  }

  public static <K> void PriorityQueueSort(Iterable<? extends K> list,
        PriorityQueue<? super K, ?> queue) {

      for (K item : list) {
          queue.insert(item, null);
      }

      list.clear();
  }

  public static void main(String[] args) {
    PriorityQueue<Integer, Integer> pq = 
        new PriorityQueue<Integer, Integer>();

    pq.insert(4, 2);
    pq.insert(5, 1);


    System.out.println(pq.min().toString());
  }
}

Answer 1

目前你所获得的方法在方法签名方面没有意义 - 例如，它可以传递List<Button>和PriorityQueue<String>。

我怀疑你真的想要这样的东西：

public static <T> void prioritySortQueue(Iterable<? extends T> iterable,
    PriorityQueue<? super T> queue) {

    for (T item : iterable) {
        queue.add(item);
    }
}

请注意，此处的差异只是提供了更大的灵活性 - 例如，您可以拥有List<Circle>但PriorityQueue<Shape>，而且它仍然是类型安全的。

编辑：既然我们有更多细节，我想你想要这样的东西：

public static <K> void prioritySortQueue(Iterable<? extends K> iterable,
    PriorityQueue<? super K, ?> queue) {

    for (T item : iterable) {
        queue.put(item, null);
    }
}

（假设您使用put方法。我们仍然不知道您的PriorityQueue课程是什么样的。）

Answer 2

您需要使方法具有通用性，以便您可以参考类型：

public static <T> void PriorityQueueSort(Iterable<T> list, 
PriorityQueue<?,T> pq) {

当类型未知时，如何迭代Iterable对象？

2 个答案: