Klase Stek i Red, verzije 1.0.0

diff --git a/kodovi/stek-i-red-opsluzivanja/Red.java b/kodovi/stek-i-red-opsluzivanja/Red.java
new file mode 100644 (file)
index 0000000..37f63ca
--- /dev/null
+++ b/kodovi/stek-i-red-opsluzivanja/Red.java
@@ -0,0 +1,174 @@
+/**\r
+ * Tip podataka red opsluživanja, koji omogućava skladištenje podataka u skladu\r
+ * sa principom "prvi unutra, prvi napolje".\r
+ * \r
+ * <p>\r
+ * Ova klasa koristi niz za skladištenje podataka, te je samim tim ograničena i\r
+ * moguće je da metod za dodavanje elemenata baci izuzetak u slučaju da više\r
+ * nema mesta.\r
+ * </p>\r
+ *\r
+ * @version v1.0.0\r
+ *\r
+ * @param <T>\r
+ *            Tip podataka koji će se čuvati u konkretnoj instanci reda\r
+ *            opsluživanja.\r
+ */\r
+public class Red<T> {\r
+       /**\r
+        * Separator vrednosti u {@code toString} metodu: {@value} .\r
+        */\r
+       public static final String SEPARATOR = ", ";\r
+\r
+       private int prvi, poslednji;\r
+       private T[] elementi;\r
+\r
+       /**\r
+        * Veličina redova za koje nije prosleđen parametar o veličini. Konkretna\r
+        * vrednost je {@value} .\r
+        */\r
+       public static final int PODRAZUMEVANA_VELICINA = 100;\r
+\r
+       /**\r
+        * Kreira novi red opsluživanja podrazumevane veličine\r
+        * {@value #PODRAZUMEVANA_VELICINA}.\r
+        */\r
+       public Red() {\r
+               this(PODRAZUMEVANA_VELICINA);\r
+       }\r
+\r
+       /**\r
+        * Kreira novi red opsluživanja zadate veličine.\r
+        * \r
+        * @param n\r
+        *            broj elemenata koji red opsluživanja može maksimalno da primi.\r
+        */\r
+       // poželjno koristiti Suppress da kompajliranje ne prijavljuje upozorenja\r
+       @SuppressWarnings("unchecked")\r
+       public Red(int n) {\r
+               prvi = -1;\r
+               poslednji = -1;\r
+               elementi = (T[]) (new Object[n]);\r
+       }\r
+\r
+       /**\r
+        * Pomoćni metod za zadržavanje indeksa niza u opsegu. Metod uvek vraća\r
+        * indeks sledećeg elementa u odnosu na onaj koji je prosleđen. Sledeći\r
+        * element je za jedno mesto više od trenutnog, osim za poslednji kome je\r
+        * sledeći prvi.\r
+        * \r
+        * @param i\r
+        *            indeks elementa za koji se traži sledeći\r
+        * @return indeks elementa koji je posle onog koji je prosleđen.\r
+        */\r
+       private int dodajJedan(int i) {\r
+               return (i + 1) % elementi.length;\r
+       }\r
+\r
+       /**\r
+        * Vraća da li je red prazan.\r
+        * \r
+        * @return da li je red prazan\r
+        */\r
+       public boolean jePrazan() {\r
+               return poslednji == -1;\r
+       }\r
+\r
+       /**\r
+        * Vraća da li je red pun.\r
+        * \r
+        * @return da li je red pun\r
+        */\r
+       public boolean jePun() {\r
+               return dodajJedan(poslednji) == prvi;\r
+       }\r
+\r
+       /**\r
+        * Vraća vrednost elementa na početku reda opsluživanja. Ukoliko je red\r
+        * prazan baca se izuzetak.\r
+        * \r
+        * @return vrednost elementa na početku reda opsluživanja\r
+        */\r
+       public T prvi() {\r
+               if (jePrazan())\r
+                       throw new IllegalStateException("Red je prazan");\r
+               else\r
+                       return elementi[prvi];\r
+       }\r
+\r
+       /**\r
+        * Izbacuje element sa početka reda opsluživanja i vraća ga. Ukoliko je red\r
+        * prazan baca se izuzetak.\r
+        * \r
+        * @return vrednost elementa koji je bio na početku reda opsluživanja\r
+        */\r
+       public T izbaciPrvi() {\r
+               if (jePrazan()) {\r
+                       throw new IllegalStateException("Red je prazan");\r
+               } else {\r
+                       T el = elementi[prvi];\r
+                       if (prvi == poslednji) {\r
+                               prvi = -1;\r
+                               poslednji = -1;\r
+                       } else\r
+                               prvi = dodajJedan(prvi);\r
+                       return el;\r
+               }\r
+       }\r
+\r
+       /**\r
+        * Ubacuje prosleđeni element na kraj reda opsluživanja. Ukoliko je red već\r
+        * pun baca se izuzetak.\r
+        * \r
+        * @param x\r
+        *            element koji će biti ubačen na kraj reda\r
+        */\r
+       public void naKraj(T x) {\r
+               if (jePun())\r
+                       throw new IllegalStateException("Red je pun");\r
+               else {\r
+                       if (jePrazan()) {\r
+                               prvi = 0;\r
+                               poslednji = 0;\r
+                       } else\r
+                               poslednji = dodajJedan(poslednji);\r
+                       elementi[poslednji] = x;\r
+               }\r
+       }\r
+\r
+       /**\r
+        * Vraća String reprezentaciju ovog Reda. Reprezentacija će sadržati\r
+        * najviše 4 elementa iz reda, tačnije najviše prva dva i poslednja dva,\r
+        * razdvojenih sa {@value #SEPARATOR}, a ukoliko ima više od 4 elementa biće\r
+        * dodato i "..." između prvih i poslednjih elemenata.\r
+        */\r
+       public String toString() {\r
+               String rez = "Red:";\r
+\r
+               if (jePrazan()) {\r
+                       rez += "prazan";\r
+               } else {\r
+                       rez += elementi[prvi];\r
+                       if (prvi != poslednji) {\r
+                               int drugi = dodajJedan(prvi);\r
+                               rez += SEPARATOR + elementi[drugi];\r
+                               if (drugi != poslednji) {\r
+\r
+                                       int predposlednji = poslednji - 1;\r
+                                       if (poslednji == 0) {\r
+                                               predposlednji = elementi.length - 1;\r
+                                       }\r
+                                       \r
+                                       if (predposlednji != drugi) {\r
+                                               if (dodajJedan(drugi) != predposlednji) {\r
+                                                       rez += SEPARATOR + "...";\r
+                                               }\r
+                                               rez += SEPARATOR + elementi[predposlednji];\r
+                                       }\r
+                                       rez += SEPARATOR + elementi[poslednji];\r
+                               }\r
+                       }\r
+               }\r
+               return rez;\r
+       }\r
+}
\ No newline at end of file

diff --git a/kodovi/stek-i-red-opsluzivanja/Stek.java b/kodovi/stek-i-red-opsluzivanja/Stek.java
new file mode 100644 (file)
index 0000000..a3e07c9
--- /dev/null
+++ b/kodovi/stek-i-red-opsluzivanja/Stek.java
@@ -0,0 +1,143 @@
+/**\r
+ * Tip podataka stek, koji omogućava skladištenje podataka u skladu sa principom\r
+ * "poslednji unutra, prvi napolje".\r
+ * \r
+ * <p>\r
+ * Implementacija koristi niz, te je u skladu sa tim ograničena veličina steka\r
+ * koji se koristi i moguće je da će operacija za dodavanje elemenata baciti\r
+ * izuzetak ukoliko nema mesta.\r
+ * </p>\r
+ * \r
+ * @version v1.0.0\r
+ * \r
+ * @param <T>\r
+ *            Tip podataka koji će se čuvati u konkretnoj instanci steka.\r
+ */\r
+public class Stek<T> {\r
+       /**\r
+        * Separator vrednosti u {@code toString} metodu: {@value} .\r
+        */\r
+       public static final String SEPARATOR = ", ";\r
+\r
+       // indeks prvog slobodnog elementa na steku\r
+       private int popunjeno;\r
+\r
+       // niz u kome se skladiste elementi\r
+       private T[] elementi;\r
+\r
+       /**\r
+        * Veličina stekova za koje nije prosledjen parametar o veličini ({@value}\r
+        * ).\r
+        */\r
+       public static final int PODRAZUMEVANA_VELICINA = 100;\r
+\r
+       /**\r
+        * Kreira novi Stek podrazumevane veličine {@value #PODRAZUMEVANA_VELICINA}.\r
+        */\r
+       public Stek() {\r
+               this(PODRAZUMEVANA_VELICINA);\r
+       }\r
+\r
+       /**\r
+        * Kreira nov Stek zadate velicine.\r
+        * \r
+        * @param n\r
+        *            maksimalan broj elemenata koji će ovaj stek moći da primi.\r
+        */\r
+       // pozeljno koristiti Suppress da kompajliranje ne prijavljuje upozorenja\r
+       @SuppressWarnings("unchecked")\r
+       public Stek(int n) {\r
+               popunjeno = 0;\r
+               elementi = (T[]) (new Object[n]);\r
+       }\r
+\r
+       /**\r
+        * Vraća da li je stek prazan.\r
+        * \r
+        * @return da li je stek prazan\r
+        */\r
+       public boolean jePrazan() {\r
+               return popunjeno == 0;\r
+       }\r
+\r
+       /**\r
+        * Vraća da li je stek pun.\r
+        * \r
+        * @return da li je stek pun\r
+        */\r
+       public boolean jePun() {\r
+               return popunjeno == elementi.length;\r
+       }\r
+\r
+       /**\r
+        * Vraća vrednost elementa na vrhu steka. Ukoliko je stek prazan baca\r
+        * izuzetak.\r
+        * \r
+        * @return vrednost elementa na vrhu steka\r
+        */\r
+       public T vrh() {\r
+               if (jePrazan()) {\r
+                       throw new IllegalStateException("Stek je prazan");\r
+               } else\r
+                       return elementi[popunjeno - 1];\r
+       }\r
+\r
+       /**\r
+        * Skida element sa vrha steka i vraća ga. Ukoliko je stek prazan baca se\r
+        * izuzetak.\r
+        * \r
+        * @return vrednost elementa koji je bio na vrhu steka\r
+        */\r
+       public T skiniVrh() {\r
+               if (jePrazan()) {\r
+                       throw new IllegalStateException("Stek je prazan");\r
+               } else\r
+                       popunjeno--;\r
+               return elementi[popunjeno];\r
+       }\r
+\r
+       /**\r
+        * Ubacuje prosleđeni element na vrh steka. Ukoliko je stek već pun baca se\r
+        * izuzetak.\r
+        * \r
+        * @param x\r
+        *            element koji će biti ubačen na vrh steka\r
+        */\r
+       public void stavi(T x) {\r
+               if (jePun()) {\r
+                       throw new IllegalStateException("Stek je pun");\r
+               } else {\r
+                       elementi[popunjeno] = x;\r
+                       popunjeno++;\r
+               }\r
+       }\r
+\r
+       /**\r
+        * Vraća String reprezentaciju ovog Steka. Reprezentacija će sadržati\r
+        * najviše 4 elementa sa steka, tačnije najviše prva dva i poslednja dva,\r
+        * razdvojenih sa {@value #SEPARATOR}, a ukoliko ima više od 4 elementa biće\r
+        * dodato i "..." između prvih i poslednjih elemenata.\r
+        */\r
+       public String toString() {\r
+               String rez = "Stek: ";\r
+               if (jePrazan()) {\r
+                       rez += "prazan";\r
+               } else {\r
+                       rez += elementi[popunjeno - 1];\r
+                       if (popunjeno > 1) {\r
+                               int sledeci = popunjeno - 2;\r
+                               rez += SEPARATOR + elementi[sledeci];\r
+                               if (popunjeno > 2) {\r
+                                       if (popunjeno > 4) {\r
+                                               rez += SEPARATOR + "...";\r
+                                       }\r
+                                       if (popunjeno > 3) {\r
+                                               rez += SEPARATOR + elementi[1];\r
+                                       }\r
+                                       rez += SEPARATOR + elementi[0];\r
+                               }\r
+                       }\r
+               }\r
+               return rez;\r
+       }\r
+}
\ No newline at end of file