332 lines
9.1 KiB
Java
332 lines
9.1 KiB
Java
import java.util.Collection;
|
|
import java.util.Comparator;
|
|
import java.util.Iterator;
|
|
import java.util.NavigableSet;
|
|
import java.util.SortedSet;
|
|
import java.util.TreeSet;
|
|
|
|
public class TreeSetImpl<E>
|
|
{
|
|
private TreeSet<E> treeSet;
|
|
|
|
/*
|
|
* Constructs a new, empty tree set, sorted according to the natural
|
|
* ordering of its elements.
|
|
*/
|
|
public TreeSetImpl()
|
|
{
|
|
treeSet = new TreeSet<E>();
|
|
}
|
|
|
|
/*
|
|
* Constructs a new tree set containing the elements in the specified
|
|
* collection, sorted according to the natural ordering of its elements.
|
|
*/
|
|
public TreeSetImpl(Collection<? extends E> c)
|
|
{
|
|
treeSet = new TreeSet<E>(c);
|
|
}
|
|
|
|
/*
|
|
* Constructs a new, empty tree set, sorted according to the specified
|
|
* comparator.
|
|
*/
|
|
public TreeSetImpl(Comparator<? super E> comparator)
|
|
{
|
|
treeSet = new TreeSet<E>(comparator);
|
|
}
|
|
|
|
/*
|
|
* Constructs a new tree set containing the same elements and using the same
|
|
* ordering as the specified sorted set.
|
|
*/
|
|
public TreeSetImpl(SortedSet<E> s)
|
|
{
|
|
treeSet = new TreeSet<E>(s);
|
|
}
|
|
|
|
/* Adds the specified element to this set if it is not already present. */
|
|
public boolean add(E e)
|
|
{
|
|
return treeSet.add(e);
|
|
}
|
|
|
|
/* Adds all of the elements in the specified collection to this set. */
|
|
public boolean addAll(Collection<? extends E> c)
|
|
{
|
|
return treeSet.addAll(c);
|
|
}
|
|
|
|
/*
|
|
* Returns the least element in this set greater than or equal to the given
|
|
* element, or null if there is no such element.
|
|
*/
|
|
public E ceiling(E e)
|
|
{
|
|
return treeSet.ceiling(e);
|
|
}
|
|
|
|
/* Removes all of the elements from this set. */
|
|
public void clear()
|
|
{
|
|
treeSet.clear();
|
|
}
|
|
|
|
/* Returns a shallow copy of this TreeSet instance. */
|
|
public Object clone()
|
|
{
|
|
return treeSet.clone();
|
|
}
|
|
|
|
/*
|
|
* Returns the comparator used to order the elements in this set, or null if
|
|
* this set uses the natural ordering of its elements.
|
|
*/
|
|
public Comparator<? super E> comparator()
|
|
{
|
|
return treeSet.comparator();
|
|
}
|
|
|
|
/* Returns true if this set contains the specified element. */
|
|
public boolean contains(Object o)
|
|
{
|
|
return treeSet.contains(o);
|
|
}
|
|
|
|
/* Returns an iterator over the elements in this set in descending order. */
|
|
public Iterator<E> descendingIterator()
|
|
{
|
|
return treeSet.descendingIterator();
|
|
}
|
|
|
|
/* Returns a reverse order view of the elements contained in this set. */
|
|
public NavigableSet<E> descendingSet()
|
|
{
|
|
return treeSet.descendingSet();
|
|
}
|
|
|
|
/* Returns the first (lowest) element currently in this set. */
|
|
public E first()
|
|
{
|
|
return treeSet.first();
|
|
}
|
|
|
|
/*
|
|
* Returns the greatest element in this set less than or equal to the given
|
|
* element, or null if there is no such element.
|
|
*/
|
|
public E floor(E e)
|
|
{
|
|
return treeSet.floor(e);
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements are strictly
|
|
* less than toElement.
|
|
*/
|
|
public SortedSet<E> headSet(E toElement)
|
|
{
|
|
return treeSet.headSet(toElement);
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements are less than
|
|
* (or equal to, if inclusive is true) toElement.
|
|
*/
|
|
public NavigableSet<E> headSet(E toElement, boolean inclusive)
|
|
{
|
|
return treeSet.headSet(toElement, inclusive);
|
|
}
|
|
|
|
/*
|
|
* Returns the least element in this set strictly greater than the given
|
|
* element, or null if there is no such element.
|
|
*/
|
|
public E higher(E e)
|
|
{
|
|
return treeSet.higher(e);
|
|
}
|
|
|
|
/* Returns true if this set contains no elements. */
|
|
public boolean isEmpty()
|
|
{
|
|
return treeSet.isEmpty();
|
|
}
|
|
|
|
/* Returns an iterator over the elements in this set in ascending order. */
|
|
public Iterator<E> iterator()
|
|
{
|
|
return treeSet.iterator();
|
|
}
|
|
|
|
/* Returns the last (highest) element currently in this set. */
|
|
public E last()
|
|
{
|
|
return treeSet.last();
|
|
}
|
|
|
|
/*
|
|
* Returns the greatest element in this set strictly less than the given
|
|
* element, or null if there is no such element.
|
|
*/
|
|
public E lower(E e)
|
|
{
|
|
return treeSet.lower(e);
|
|
}
|
|
|
|
/*
|
|
* Retrieves and removes the first (lowest) element, or returns null if this
|
|
* set is empty.
|
|
*/
|
|
public E pollFirst()
|
|
{
|
|
return treeSet.pollFirst();
|
|
}
|
|
|
|
/*
|
|
* Retrieves and removes the last (highest) element, or returns null if this
|
|
* set is empty.
|
|
*/
|
|
public E pollLast()
|
|
{
|
|
return treeSet.pollLast();
|
|
}
|
|
|
|
/* Removes the specified element from this set if it is present. */
|
|
public boolean remove(Object o)
|
|
{
|
|
return treeSet.remove(o);
|
|
}
|
|
|
|
/* Returns the number of elements in this set (its cardinality). */
|
|
public int size()
|
|
{
|
|
return treeSet.size();
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements range from
|
|
* fromElement to toElement.
|
|
*/
|
|
public NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive)
|
|
{
|
|
return treeSet.subSet(fromElement, fromInclusive, toElement,toInclusive);
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements range from
|
|
* fromElement, inclusive, to toElement, exclusive.
|
|
*/
|
|
public SortedSet<E> subSet(E fromElement, E toElement)
|
|
{
|
|
return treeSet.subSet(fromElement, toElement);
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements are greater than
|
|
* or equal to fromElement.
|
|
*/
|
|
public SortedSet<E> tailSet(E fromElement)
|
|
{
|
|
return treeSet.tailSet(fromElement);
|
|
}
|
|
|
|
/*
|
|
* Returns a view of the portion of this set whose elements are greater than
|
|
* (or equal to, if inclusive is true) fromElement.
|
|
*/
|
|
public NavigableSet<E> tailSet(E fromElement, boolean inclusive)
|
|
{
|
|
return treeSet.tailSet(fromElement, inclusive);
|
|
}
|
|
|
|
public static void main(String... arg)
|
|
{
|
|
TreeSetImpl<Integer> treeSet = new TreeSetImpl<Integer>();
|
|
treeSet.add(10);
|
|
treeSet.add(20);
|
|
treeSet.add(30);
|
|
treeSet.add(40);
|
|
treeSet.add(5);
|
|
treeSet.add(-10);
|
|
Iterator<Integer> titerator = treeSet.iterator();
|
|
System.out.println("the elements are");
|
|
while (titerator.hasNext())
|
|
{
|
|
System.out.print(titerator.next() + "\t");
|
|
}
|
|
System.out.println();
|
|
System.out.println("the size of the TreeSet is " + treeSet.size());
|
|
System.out.println("the ceiling of -100 in the TreeSet is "+ treeSet.ceiling(-100));
|
|
Iterator<Integer> revitr = treeSet.descendingIterator();
|
|
System.out.println("the reverse order is ");
|
|
while (revitr.hasNext())
|
|
{
|
|
System.out.print(revitr.next() + "\t");
|
|
}
|
|
System.out.println();
|
|
System.out.println("the lowest element in the set is " + treeSet.first());
|
|
System.out.println("the floor of 20 in treeSet is " + treeSet.floor(20));
|
|
System.out.println("the last element in the set is " + treeSet.last());
|
|
System.out.println("element 20 removed is " + treeSet.remove(20));
|
|
if (treeSet.isEmpty())
|
|
System.out.println("the set is empty");
|
|
else
|
|
System.out.println("the set is not empty");
|
|
NavigableSet<Integer> navigableSet;
|
|
Iterator<Integer> itr;
|
|
System.out.println("the headSet of 40 is ");
|
|
navigableSet = treeSet.headSet(40, true);
|
|
itr = navigableSet.iterator();
|
|
while (itr.hasNext())
|
|
{
|
|
System.out.println(itr.next() + "\t");
|
|
}
|
|
System.out.println();
|
|
System.out.println("the subset between 5 and 30 ");
|
|
navigableSet = treeSet.subSet(5, true, 30, true);
|
|
itr = navigableSet.iterator();
|
|
while (itr.hasNext())
|
|
{
|
|
System.out.println(itr.next() + "\t");
|
|
}
|
|
System.out.println();
|
|
System.out.println("the tailSet of 10 is ");
|
|
navigableSet = treeSet.tailSet(10, true);
|
|
itr = navigableSet.iterator();
|
|
while (itr.hasNext())
|
|
{
|
|
System.out.println(itr.next() + "\t");
|
|
}
|
|
System.out.println();
|
|
}
|
|
}
|
|
|
|
/*
|
|
the elements are
|
|
-10 5 10 20 30 40
|
|
the size of the TreeSet is 6
|
|
the ceiling of -100 in the TreeSet is -10
|
|
the reverse order is
|
|
40 30 20 10 5 -10
|
|
the lowest element in the set is -10
|
|
the floor of 20 in treeSet is 20
|
|
the last element in the set is 40
|
|
element 20 removed is true
|
|
the set is not empty
|
|
the headSet of 40 is
|
|
-10
|
|
5
|
|
10
|
|
30
|
|
40
|
|
|
|
the subset between 5 and 30
|
|
5
|
|
10
|
|
30
|
|
|
|
the tailSet of 10 is
|
|
10
|
|
30
|
|
40 |