kodovi/simulacija-rekurzije/Stek.java

   1 /**
   2  * Tip podataka stek, koji omogućava skladištenje podataka u skladu sa principom
   3  * "poslednji unutra, prvi napolje".
   4  *
   5  * <p>
   6  * Implementacija koristi niz, te je u skladu sa tim ograničena veličina steka
   7  * koji se koristi i moguće je da će operacija za dodavanje elemenata baciti
   8  * izuzetak ukoliko nema mesta.
   9  * </p>
  10  *
  11  * @version v1.0.0
  12  *
  13  * @param <T>
  14  *            Tip podataka koji će se čuvati u konkretnoj instanci steka.
  15  */
  16 public class Stek<T> {
  17         /**
  18          * Separator vrednosti u {@code toString} metodu: {@value} .
  19          */
  20         public static final String SEPARATOR = ", ";
  21
  22         // indeks prvog slobodnog elementa na steku
  23         private int popunjeno;
  24
  25         // niz u kome se skladiste elementi
  26         private T[] elementi;
  27
  28         /**
  29          * Veličina stekova za koje nije prosledjen parametar o veličini ({@value}
  30          * ).
  31          */
  32         public static final int PODRAZUMEVANA_VELICINA = 100;
  33
  34         /**
  35          * Kreira novi Stek podrazumevane veličine {@value #PODRAZUMEVANA_VELICINA}.
  36          */
  37         public Stek() {
  38                 this(PODRAZUMEVANA_VELICINA);
  39         }
  40
  41         /**
  42          * Kreira nov Stek zadate velicine.
  43          *
  44          * @param n
  45          *            maksimalan broj elemenata koji će ovaj stek moći da primi.
  46          */
  47         // pozeljno koristiti Suppress da kompajliranje ne prijavljuje upozorenja
  48         @SuppressWarnings("unchecked")
  49         public Stek(int n) {
  50                 popunjeno = 0;
  51                 elementi = (T[]) (new Object[n]);
  52         }
  53
  54         /**
  55          * Vraća da li je stek prazan.
  56          *
  57          * @return da li je stek prazan
  58          */
  59         public boolean jePrazan() {
  60                 return popunjeno == 0;
  61         }
  62
  63         /**
  64          * Vraća da li je stek pun.
  65          *
  66          * @return da li je stek pun
  67          */
  68         public boolean jePun() {
  69                 return popunjeno == elementi.length;
  70         }
  71
  72         /**
  73          * Vraća vrednost elementa na vrhu steka. Ukoliko je stek prazan baca
  74          * izuzetak.
  75          *
  76          * @return vrednost elementa na vrhu steka
  77          */
  78         public T vrh() {
  79                 if (jePrazan()) {
  80                         throw new IllegalStateException("Stek je prazan");
  81                 } else
  82                         return elementi[popunjeno - 1];
  83         }
  84
  85         /**
  86          * Skida element sa vrha steka i vraća ga. Ukoliko je stek prazan baca se
  87          * izuzetak.
  88          *
  89          * @return vrednost elementa koji je bio na vrhu steka
  90          */
  91         public T skiniVrh() {
  92                 if (jePrazan()) {
  93                         throw new IllegalStateException("Stek je prazan");
  94                 } else
  95                         popunjeno--;
  96                 return elementi[popunjeno];
  97         }
  98
  99         /**
 100          * Ubacuje prosleđeni element na vrh steka. Ukoliko je stek već pun baca se
 101          * izuzetak.
 102          *
 103          * @param x
 104          *            element koji će biti ubačen na vrh steka
 105          */
 106         public void stavi(T x) {
 107                 if (jePun()) {
 108                         throw new IllegalStateException("Stek je pun");
 109                 } else {
 110                         elementi[popunjeno] = x;
 111                         popunjeno++;
 112                 }
 113         }
 114
 115         /**
 116          * Vraća String reprezentaciju ovog Steka. Reprezentacija će sadržati
 117          * najviše 4 elementa sa steka, tačnije najviše prva dva i poslednja dva,
 118          * razdvojenih sa {@value #SEPARATOR}, a ukoliko ima više od 4 elementa biće
 119          * dodato i "..." između prvih i poslednjih elemenata.
 120          */
 121         public String toString() {
 122                 String rez = "Stek: ";
 123                 if (jePrazan()) {
 124                         rez += "prazan";
 125                 } else {
 126                         rez += elementi[popunjeno - 1];
 127                         if (popunjeno > 1) {
 128                                 int sledeci = popunjeno - 2;
 129                                 rez += SEPARATOR + elementi[sledeci];
 130                                 if (popunjeno > 2) {
 131                                         if (popunjeno > 4) {
 132                                                 rez += SEPARATOR + "...";
 133                                         }
 134                                         if (popunjeno > 3) {
 135                                                 rez += SEPARATOR + elementi[1];
 136                                         }
 137                                         rez += SEPARATOR + elementi[0];
 138                                 }
 139                         }
 140                 }
 141                 return rez;
 142         }
 143 }