RedBlackTreeInteger (lecousin.net Java core framework 0.16.2 API)

java.lang.Object
- net.lecousin.framework.collections.sort.RedBlackTreeInteger<T>

Type Parameters:

T - type of elements

All Implemented Interfaces:

Iterable<T>, Sorted<T>, Sorted.AssociatedWithInteger<T>
```
public class RedBlackTreeInteger<T>
extends Object
implements Sorted.AssociatedWithInteger<T>
```
Sorted list, where each element is associated with an integer value used to compare elements. To sort the elements, a red-black tree is used.

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class RedBlackTreeInteger.Node<T>
Node in the RedBlackTree.
- Nested classes/interfaces inherited from interface net.lecousin.framework.collections.sort.Sorted
  Sorted.AssociatedWithInteger<T>, Sorted.AssociatedWithLong<T>

Nested Classes
Modifier and Type	Class and Description
`static class`	`RedBlackTreeInteger.Node<T>` Node in the RedBlackTree.

Constructor Summary

Constructors
Constructor and Description

RedBlackTreeInteger()

Constructors
Constructor and Description
`RedBlackTreeInteger()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`add(int value, T element)` Add an element.
`void`	`clear()` Clear this collection.
`boolean`	`contains(int value, T element)` Returns true if the given key exists in the tree and its associated value is the given element.
`boolean`	`containsInstance(int value, T instance)` Returns true if the given key exists in the tree and its associated value is the given element.
`boolean`	`containsKey(int value)` Returns true if the given key exists in the tree.
`RedBlackTreeInteger.Node<T>`	`get(int value)` Returns the node associated to the given key, or null if no such key exists.
`RedBlackTreeInteger.Node<T>`	`getMax()`
`RedBlackTreeInteger.Node<T>`	`getMin()`
`RedBlackTreeInteger.Node<T>`	`getNext(int value)` Returns the node containing the key just before the given key.
`RedBlackTreeInteger.Node<T>`	`getNext(RedBlackTreeInteger.Node<T> node)` Returns the node containing the key just before the key of the given node.
`RedBlackTreeInteger.Node<T>`	`getPrevious(int value)` Returns the node containing the key just before the given key.
`RedBlackTreeInteger.Node<T>`	`getPrevious(RedBlackTreeInteger.Node<T> node)` Returns the node containing the key just before the key of the given node.
`boolean`	`isEmpty()` Return true if this collection is empty.
`Iterator<T>`	`iterator()`
`Iterator<RedBlackTreeInteger.Node<T>>`	`nodeIterator()`
`Iterator<RedBlackTreeInteger.Node<T>>`	`nodeIteratorOrdered()`
`Iterator<RedBlackTreeInteger.Node<T>>`	`nodeIteratorReverse()`
`Iterator<T>`	`orderedIterator()` Return an iterator that iterates on the correct order.
`void`	`remove(int key, T element)` Remove the node containing the given key and element.
`void`	`remove(RedBlackTreeInteger.Node<T> node)` Remove the given node.
`void`	`removeInstance(int key, T instance)` Remove the node containing the given key and element.
`void`	`removeKey(int key)` Remove the given key.
`void`	`removeMax()` Remove the last element.
`void`	`removeMin()` Remove the first element.
`Iterator<T>`	`reverseOrderIterator()` Return an iterator that iterates on the correct order.
`RedBlackTreeInteger.Node<T>`	`searchNearestHigher(int value, boolean acceptEquals)` Returns the node containing the lowest value strictly higher than the given one.
`RedBlackTreeInteger.Node<T>`	`searchNearestLower(int value, boolean acceptEquals)` Returns the node containing the highest value strictly lower than the given one.
`int`	`size()` Number of elements in this collection.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.lang.Iterable
forEach, spliterator

- Constructor Detail
  - RedBlackTreeInteger
```
public RedBlackTreeInteger()
```
- Method Detail
  - size
```
public int size()
```
    Description copied from interface: Sorted
    
    Number of elements in this collection.
    
    Specified by:
    
    size in interface Sorted<T>
  - isEmpty
```
public boolean isEmpty()
```
    Description copied from interface: Sorted
    
    Return true if this collection is empty.
    
    Specified by:
    
    isEmpty in interface Sorted<T>
  - clear
```
public void clear()
```
    Description copied from interface: Sorted
    
    Clear this collection.
    
    Specified by:
    
    clear in interface Sorted<T>
  - get
```
public RedBlackTreeInteger.Node<T> get(int value)
```
    Returns the node associated to the given key, or null if no such key exists.
  - getPrevious
```
public RedBlackTreeInteger.Node<T> getPrevious(int value)
```
    Returns the node containing the key just before the given key.
  - getPrevious
```
public RedBlackTreeInteger.Node<T> getPrevious(RedBlackTreeInteger.Node<T> node)
```
    Returns the node containing the key just before the key of the given node.
  - getNext
```
public RedBlackTreeInteger.Node<T> getNext(int value)
```
    Returns the node containing the key just before the given key.
  - getNext
```
public RedBlackTreeInteger.Node<T> getNext(RedBlackTreeInteger.Node<T> node)
```
    Returns the node containing the key just before the key of the given node.
  - containsKey
```
public boolean containsKey(int value)
```
    Returns true if the given key exists in the tree.
  - contains
```
public boolean contains(int value,
                        T element)
```
    Returns true if the given key exists in the tree and its associated value is the given element. Comparison of the element is using the equals method.
    
    Specified by:
    
    contains in interface Sorted.AssociatedWithInteger<T>
  - containsInstance
```
public boolean containsInstance(int value,
                                T instance)
```
    Returns true if the given key exists in the tree and its associated value is the given element. Comparison of the element is using the == operator.
    
    Specified by:
    
    containsInstance in interface Sorted.AssociatedWithInteger<T>
  - getMin
```
public RedBlackTreeInteger.Node<T> getMin()
```
  - getMax
```
public RedBlackTreeInteger.Node<T> getMax()
```
  - searchNearestLower
```
public RedBlackTreeInteger.Node<T> searchNearestLower(int value,
                                                      boolean acceptEquals)
```
    Returns the node containing the highest value strictly lower than the given one.
  - searchNearestHigher
```
public RedBlackTreeInteger.Node<T> searchNearestHigher(int value,
                                                       boolean acceptEquals)
```
    Returns the node containing the lowest value strictly higher than the given one.
  - add
```
public void add(int value,
                T element)
```
    Description copied from interface: Sorted.AssociatedWithInteger
    
    Add an element.
    
    Specified by:
    
    add in interface Sorted.AssociatedWithInteger<T>
  - removeMin
```
public void removeMin()
```
    Remove the first element.
  - removeMax
```
public void removeMax()
```
    Remove the last element.
  - remove
```
public void remove(RedBlackTreeInteger.Node<T> node)
```
    Remove the given node.
  - remove
```
public void remove(int key,
                   T element)
```
    Remove the node containing the given key and element. The node MUST exists, else the tree won't be valid anymore.
    
    Specified by:
    
    remove in interface Sorted.AssociatedWithInteger<T>
  - removeKey
```
public void removeKey(int key)
```
    Remove the given key. The key MUST exists, else the tree won't be valid anymore.
  - removeInstance
```
public void removeInstance(int key,
                           T instance)
```
    Remove the node containing the given key and element. The node MUST exists, else the tree won't be valid anymore.
    
    Specified by:
    
    removeInstance in interface Sorted.AssociatedWithInteger<T>
  - iterator
```
public Iterator<T> iterator()
```
    Specified by:
    
    iterator in interface Iterable<T>
  - nodeIterator
```
public Iterator<RedBlackTreeInteger.Node<T>> nodeIterator()
```
  - nodeIteratorOrdered
```
public Iterator<RedBlackTreeInteger.Node<T>> nodeIteratorOrdered()
```
  - nodeIteratorReverse
```
public Iterator<RedBlackTreeInteger.Node<T>> nodeIteratorReverse()
```
  - orderedIterator
```
public Iterator<T> orderedIterator()
```
    Description copied from interface: Sorted
    
    Return an iterator that iterates on the correct order.
    
    Specified by:
    
    orderedIterator in interface Sorted<T>
  - reverseOrderIterator
```
public Iterator<T> reverseOrderIterator()
```
    Description copied from interface: Sorted
    
    Return an iterator that iterates on the correct order.
    
    Specified by:
    
    reverseOrderIterator in interface Sorted<T>

Class RedBlackTreeInteger<T>

Nested Class Summary

Nested classes/interfaces inherited from interface net.lecousin.framework.collections.sort.Sorted

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.Iterable

Constructor Detail

RedBlackTreeInteger

Method Detail

size

isEmpty

clear

get

getPrevious

getPrevious

getNext

getNext

containsKey

contains

containsInstance

getMin

getMax

searchNearestLower

searchNearestHigher

add

removeMin

removeMax

remove

remove

removeKey

removeInstance

iterator

nodeIterator

nodeIteratorOrdered

nodeIteratorReverse

orderedIterator

reverseOrderIterator