Wie kann ich Durchlaufen einen Wiederholenden Objekt, wenn der Typ nicht bekannt?

Für eine Hausaufgabe brauche ich zur Umsetzung meiner eigenen PriorityQueue und PriorityQueueSort. Ich verwendet Generika, um es zu arbeiten, ohne die Sortieren-Funktion, aber nun bin ich hier hängengeblieben..

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

  for (Object obj : list) {

  }
}

Ich übergeben zu müssen, in eine Liste und eine leere PriorityQueue, also meine beste Vermutung auf, wie dies zu tun ist über. Wie sollte ich Sie angreifen, so dass ich die Liste Durchlaufen wird, mit einer unbekannten Art, und fügen Sie jedes element in dieser Liste mit der richtigen Art in die priority queue?

Edit:

Hier sind ein paar details mehr da es wurde festgestellt, dass ich nicht genügend Informationen.

Habe ich eine benutzerdefinierte Klasse PriorityQueue, und ein Eintrag eigene Klasse, die hat einen Schlüssel vom Typ K, und einen Wert vom Typ V.

Ich muss in der Lage sein, Sie zu nehmen, durchsuchbar Liste mit jeder Art T und Durchlaufen, wobei jedes Element und fügen Sie es auf einer anfangs leeren PriorityQueue als ein Schlüssel mit dem Wert null. Ich habe dann ständig anrufen removeMin() auf meinem PriorityQueue und fügen Sie es, um wieder in der gleichen Liste-Objekt.

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());
  }
}
Ihre Unterschrift ist gebrochen, und es ermöglicht es mir, fügen Sie ein Iterable<Integer> zu einem PriorityQueue<String>.

InformationsquelleAutor agent154 | 2013-03-08

  1. 9

    Was hast du im moment keinen Sinn in Bezug auf die Signatur der Methode - es würde Sie vergehen wie im List<Button> und ein PriorityQueue<String> zum Beispiel.

    Ich vermute, dass Sie tatsächlich wollen, dass so etwas wie:

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

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

    Beachten Sie, dass die Varianz hier nur mehr Flexibilität - Sie haben eine List<Circle> aber ein PriorityQueue<Shape> zum Beispiel, und es ist immer noch Typ-sicher.

    EDIT: Jetzt haben wir mehr details, ich denke, Sie wollen so etwas wie dieses:

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

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

    (Vorausgesetzt, Sie haben eine put Methode. Wir wissen immer noch nicht, was Ihr PriorityQueue Klasse aussieht.)

    Ah ja, ich vergaß Varianz.
    Ich habe meine eigene PriorityQueue<K V> Klasse und Eintrag<K V> Klasse... aber ich möchte in der Lage sein zu akzeptieren wiederholenden Art zu Sortieren. Ich weiß nicht, ob das einen Unterschied macht.
    Das bedeutet nicht einen Unterschied machen, außer dass Sie brauchen, um herauszufinden, wie man die Tasten in dieser Methode.
    Der Punkt, über den Schlüssel ist von grundlegender Bedeutung. Möchten Sie vielleicht brauchen, um auch in einem "Schlüssel-Extraktion-Funktion" oder so ähnlich. Aber du bist wahrscheinlich immer noch wollen, um es generisch.
    Ich bin verwirrt... Mein PriorityQueue hat eine Signatur von PriorityQueue<K V>, so dass ich nicht verwenden können, einen einzigen generischen Typ-Signatur von <? super T>... Also, was ist T hier?. Das erwartete Verhalten für diese Methode ist die Iteration durch die Liste jedes Element und fügen Sie es auf eine leere PriorityQueue als ein Eintrag als eine Taste mit einem null-Wert. Die Methode wird dann rufen Sie removeMin() und platzieren Sie das Element wieder in den wiederholenden Liste.

    InformationsquelleAutor Jon Skeet

  2. 3

    Müssen Sie die Methode generisch, so dass Sie können beziehen sich auf die Art:

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

    InformationsquelleAutor SLaks

Schreibe einen Kommentar