java/util/PriorityQueue.java

package java.util;

import java.util.*;

/**
 * An unbounded (resizable) priority queue based on a priority
 * heap.The take operation returns the least element with respect to
 * the given ordering. (If more than one element is tied for least
 * value, one of them is arbitrarily chosen to be returned -- no
 * guarantees are made for ordering across ties.) Ordering follows the
 * java.util.Collection conventions: Either the elements must be
 * Comparable, or a Comparator must be supplied. Comparison failures
 * throw ClassCastExceptions during insertions and extractions.
 **/
public class PriorityQueue<E> extends AbstractCollection<E> implements Queue<E> {
    public PriorityQueue(int initialCapacity) {}
    public PriorityQueue(int initialCapacity, Comparator comparator) {}

    public PriorityQueue(int initialCapacity, Collection initialElements) {}

    public PriorityQueue(int initialCapacity, Comparator comparator, Collection initialElements) {}

    public boolean add(E x) {
        return false;
    }
    public boolean offer(E x) {
        return false;
    }
    public boolean remove(Object x) {
        return false;
    }

    public E remove() {
        return null;
    }
    public Iterator<E> iterator() {
      return null;
    }

    public E element() {
        return null;
    }
    public E poll() {
        return null;
    }
    public E peek() {
        return null;
    }

    public boolean isEmpty() {
        return false;
    }
    public int size() {
        return 0;
    }
    public Object[] toArray() {
        return null;
    }

    public <T> T[] toArray(T[] array) {
        return null;
    }

}
Revision:	1.1
Committed:	Wed May 14 21:30:45 2003 UTC (20 years, 11 months ago) by tim
Branch:	MAIN
Log Message:	Moved main source rooted at . to ./src/main Moved test source rooted at ./etc/testcases to ./src/test
#	User	Rev	Content
1	tim	1.1	package java.util;
2
3			import java.util.*;
4
5			/**
6			* An unbounded (resizable) priority queue based on a priority
7			* heap.The take operation returns the least element with respect to
8			* the given ordering. (If more than one element is tied for least
9			* value, one of them is arbitrarily chosen to be returned -- no
10			* guarantees are made for ordering across ties.) Ordering follows the
11			* java.util.Collection conventions: Either the elements must be
12			* Comparable, or a Comparator must be supplied. Comparison failures
13			* throw ClassCastExceptions during insertions and extractions.
14			**/
15			public class PriorityQueue<E> extends AbstractCollection<E> implements Queue<E> {
16			public PriorityQueue(int initialCapacity) {}
17			public PriorityQueue(int initialCapacity, Comparator comparator) {}
18
19			public PriorityQueue(int initialCapacity, Collection initialElements) {}
20
21			public PriorityQueue(int initialCapacity, Comparator comparator, Collection initialElements) {}
22
23			public boolean add(E x) {
24			return false;
25			}
26			public boolean offer(E x) {
27			return false;
28			}
29			public boolean remove(Object x) {
30			return false;
31			}
32
33			public E remove() {
34			return null;
35			}
36			public Iterator<E> iterator() {
37			return null;
38			}
39
40			public E element() {
41			return null;
42			}
43			public E poll() {
44			return null;
45			}
46			public E peek() {
47			return null;
48			}
49
50			public boolean isEmpty() {
51			return false;
52			}
53			public int size() {
54			return 0;
55			}
56			public Object[] toArray() {
57			return null;
58			}
59
60			public <T> T[] toArray(T[] array) {
61			return null;
62			}
63
64			}