heap.justifiableheap

## Class RealJustifiableHeap

- java.lang.Object
- - heap.justifiableheap.RealJustifiableHeap

- All Implemented Interfaces:
    Heap, JustifiableHeap

      class RealJustifiableHeap
      extends java.lang.Object
      implements Heap, JustifiableHeap

  Implementace přerovnávací haldy.

  Popis: implementace haldy polem

  Užití: Ve svém programu deklarujte proměnné typu JustifiableHeap.

  Pozn.: v případě, že parametrem elem operace put je JustifiableHeapElement, put uloží handle do elem metodou saveHandle.

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `(package private) int` | `count` počítadlo uzlů haldy
    `(package private) int` | `size` kapacita haldy
    `private HeapTree` | `store` úložiště pro haldu

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `RealJustifiableHeap(HeapTreeFactory aTreeFactory, int heapSize)` Vyrobí instanci třídy RealJustifiableHeap.
    `RealJustifiableHeap(ShallowHeapTreeFactory aShallowFactory, SortableSequence base)` Vyrobí mělkou instanci mělké přerovnávací haldy nad posloupností base.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `adjust(SearchableElement elem)` Přemístí prvek, kterému se zmenšil klíč, na správné místo v haldě.
    `SearchableElement` | `get()` Vyjme nejmenší prvek z haldy.
    `int` | `getCount()` Zjistí počet prvků v haldě.
    `int` | `getOperationCounter()` Provozní měření.
    `boolean` | `isEmpty()` Zjistí, zda je halda prázdná.
    `boolean` | `isFull()` Zjistí, zda je halda plná.
    `void` | `justify(java.lang.Object handle)` Přemístí prvek, kterému se zmenšil klíč, na správné místo v haldě.
    `void` | `put(SearchableElement elem)` Zařadí nový prvek do haldy.
    `void` | `search(HeapCallBack callBack)` Systematicky prochází haldu vrchol po vrcholu.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### store

          private HeapTree store

      úložiště pro haldu

    - #### count

          int count

      počítadlo uzlů haldy

    - #### size

          int size

      kapacita haldy

  - ### Constructor Detail

    - #### RealJustifiableHeap

          public RealJustifiableHeap(HeapTreeFactory aTreeFactory,
                                     int heapSize)

      Vyrobí instanci třídy RealJustifiableHeap.

      Popis: inicializuje atributy instance.

      Parameters:
        `aTreeFactory` - továrna na haldy
        `heapSize` - kapacita haldy

    - #### RealJustifiableHeap

          public RealJustifiableHeap(ShallowHeapTreeFactory aShallowFactory,
                                     SortableSequence base)

      Vyrobí mělkou instanci mělké přerovnávací haldy nad posloupností base.

      Popis: inicializuje atributy instance.

      Parameters:
        `aShallowFactory` - továrna na mělké haldy
        `base` - uspořádaná posloupnost, nad kterou se postaví mělká halda

  - ### Method Detail

    - #### put

          public void put(SearchableElement elem)

      Zařadí nový prvek do haldy.

      Popis: Prohledává haldu od posledního listu ke kořenu, dokud ve stromě nachází uzly větší než nový uzel. Přitom přesouvá větší uzly shora dolů, aby uvolnil správné místo pro nový uzel. Rodič uzlu má vždy poloviční index:

                            0
                       1          2
                     3   4     5     6
                    7 8 9 10 11 12 13 14

      atd.
      Specified by:
        `put` in interface `Heap`
      Parameters:
        `elem` - prvek, který má být zařazen do haldy

    - #### adjust

          public void adjust(SearchableElement elem)

      Přemístí prvek, kterému se zmenšil klíč, na správné místo v haldě. Nově vložené prvky nebo prvky, kterým se klíč zvětšil, vložte na konec haldy (kam patří prvky s největšími klíči).

      Pozn.: v případě, že parametrem elem operace put je JustifiableHeapElement, put uloží handle do elem metodou saveHandle.

      Vyžaduje: pro prvek, který se má správně umístit, již musí být vložen do store vrchol Node a musí být běžným vrcholem.

      Parameters:
        `elem` - prvek v haldě, který má být správně umístěn

    - #### justify

          public void justify(java.lang.Object handle)

      Description copied from interface: `JustifiableHeap`
      Přemístí prvek, kterému se zmenšil klíč, na správné místo v haldě. Prvek je identifikován svým identifikačním objektem neboli handlem (typicky číslem, indexem či odkazem).
      Specified by:
        `justify` in interface `JustifiableHeap`
      Parameters:
        `handle` - identifikační objekt prvku, který se má přemístit

    - #### get

          public SearchableElement get()

      Vyjme nejmenší prvek z haldy.

      Popis: Vyjme prvek z kořene haldy. Pak prochází strom a postupně přesouvá prvky nahoru.

      Specified by:
        `get` in interface `Heap`
      Returns:
        nejmenší prvek z haldy

    - #### isEmpty

          public boolean isEmpty()

      Description copied from interface: `Heap`
      Zjistí, zda je halda prázdná.
      Specified by:
        `isEmpty` in interface `Heap`
      Returns:
        true když je prázdná, jinak false

    - #### isFull

          public boolean isFull()

      Description copied from interface: `Heap`
      Zjistí, zda je halda plná.
      Specified by:
        `isFull` in interface `Heap`
      Returns:
        true když je plná, jinak false

    - #### getOperationCounter

          public int getOperationCounter()

      Description copied from interface: `Heap`
      Provozní měření.
      Specified by:
        `getOperationCounter` in interface `Heap`
      Returns:
        počet významných operací

    - #### getCount

          public int getCount()

      Description copied from interface: `Heap`
      Zjistí počet prvků v haldě.
      Specified by:
        `getCount` in interface `Heap`
      Returns:
        počet prvků v haldě

    - #### search

          public void search(HeapCallBack callBack)

      Description copied from interface: `Heap`
      Systematicky prochází haldu vrchol po vrcholu. V každém vrcholu je uložen prvek, který se zpracuje metodou callback.ProcessCurrentElement (). Objekt callback je parametrem metody search.
      Specified by:
        `search` in interface `Heap`
      Parameters:
        `callBack` - objekt, který zpracuje každý prvek haldy