{"id":168,"date":"2018-04-09T13:57:32","date_gmt":"2018-04-09T11:57:32","guid":{"rendered":"http:\/\/www.kompikownia.pl\/?p=168"},"modified":"2018-05-02T14:33:59","modified_gmt":"2018-05-02T12:33:59","slug":"stos-pierwsze-starcie","status":"publish","type":"post","link":"https:\/\/www.kompikownia.pl\/index.php\/2018\/04\/09\/stos-pierwsze-starcie\/","title":{"rendered":"Stos – pierwsze starcie"},"content":{"rendered":"Czas czytania:<\/span> 7<\/span> minut<\/span><\/span>

Stos jest najprostsz\u0105 dynamiczn\u0105 struktur\u0105 danych. A w zwi\u0105zku z tym b\u0119dzie to tak\u017ce pierwsza dynamiczna struktura danych, kt\u00f3r\u0105 poznasz.<\/p>\n

Najpierw wyja\u015bnijmy, co to s\u0105 te dynamiczne struktury danych?<\/p>\n

Dynamiczna struktura danych – z czym to si\u0119 je?<\/b><\/strong><\/h1>\n

Zwyk\u0142\u0105 struktur\u0105 danych jest np.: na sztywno zadeklarowana tablica. Mo\u017cesz w niej przechowywa\u0107 r\u00f3\u017cne dane. Ale – rozmiar zwyk\u0142ej tablicy deklarowany jest na etapie kompilacji. W czasie dzia\u0142ania programu nie mo\u017cesz go zmieni\u0107.<\/p>\n

Czasami takie rozwi\u0105zanie nam nie przeszkadza. Je\u015bli wiemy, na jakiej ilo\u015bci danych b\u0119dzie operowa\u0142 nasz program, po prostu przygotujemy go na najgorsz\u0105 mo\u017cliw\u0105 sytuacj\u0119. Lecz takie podej\u015bcie ma kilka wad. Przede wszystkim, strasznie marnujemy pami\u0119\u0107 (obecnie i tak to nie ma znaczenia, ale my jeste\u015bmy porz\u0105dnymi programistami :-)). Po drugie, niekt\u00f3re algorytmy ci\u0119\u017cko przedstawi\u0107 w formie zwyk\u0142ej tablicy. Czasami potrzebujemy bardziej zaawansowanej struktury danych.<\/p>\n

I tu z pomoc\u0105 przychodz\u0105 dynamiczne struktury danych!<\/b><\/strong><\/h2>\n

Oczywi\u015bcie, b\u0119dzie si\u0119 z tym wi\u0105za\u0142a zabawa z najukocha\u0144szymi wska\u017anikami. Co by\u015bmy bez nich pocz\u0119li? No dobra, zaczynamy.<\/p>\n

\"stack_of_books\"
Kwintensencja stosu<\/figcaption><\/figure>\n

Stos – podstawowe informacje<\/b><\/strong><\/h1>\n

Stos dzia\u0142a na bardzo prostej zasadzie. Wyobra\u017amy sobie, \u017ce posiadamy kilka talerzy. Nasz st\u00f3\u0142, na kt\u00f3rym b\u0119dziemy je uk\u0142adali, b\u0119dzie nasz\u0105 pami\u0119ci\u0105. Zasada dotycz\u0105ca stosu jest prosta. Jedyne operacje, jakie mo\u017cemy na nim wykonywa\u0107, dotycz\u0105 szczytu stosu. Je\u015bli nasz stos jest pusty, mo\u017cemy wykona\u0107 tylko jedn\u0105 rzecz – po\u0142o\u017cy\u0107 talerz na stole. Do talerza mo\u017cemy w\u0142o\u017cy\u0107 jak\u0105\u015b karteczk\u0119 z zapisan\u0105 liczb\u0105.<\/p>\n

Hurra! Nasz stos ma ju\u017c jeden element! W tym momencie mo\u017cemy wykona\u0107 ju\u017c trzy operacje. Mo\u017cemy zobaczy\u0107, co znajduje si\u0119 na kartce znajduj\u0105cej si\u0119 na tym talerzu (funkcja peek). Mo\u017cemy do stosu do\u0142o\u017cy\u0107 kolejny talerz (funkcja push). Ostatecznie mo\u017cemy sko\u0144czy\u0107 t\u0119 zabaw\u0119 i zabra\u0107 znajduj\u0105cy si\u0119 na stole talerz.<\/p>\n

Mimo od\u0142o\u017cenia na stos kilku talerzy, zasada dost\u0119pu jedynie do szczytowego elementu dalej obowi\u0105zuje. Nie mo\u017cemy wyj\u0105\u0107 talerza znajduj\u0105cego si\u0119 w \u015brodku tego stosu ani zobaczy\u0107, co si\u0119 w nim znajduje, bo ca\u0142a nasza minsterna konstrukcja si\u0119 wtedy rozleci. Wyobra\u017amy sobie ponadto, \u017ce nasza r\u0119ka dotykaj\u0105ca talerza jest swego rodzaju wska\u017anikiem. Mo\u017ce ona dotkn\u0105\u0107 tylko talerza znajduj\u0105cego si\u0119 na szczycie. Je\u015bli jednak r\u0119ka nie b\u0119dzie wiedzia\u0142a, gdzie znajduje si\u0119 stos talerzy, to nie b\u0119dzie mo\u017cna nim zarz\u0105dza\u0107. Pami\u0119taj wi\u0119c, aby nigdy nie zgubi\u0107 wska\u017anika do wierzcho\u0142ka stosu. Jest to b\u0142\u0105d, za kt\u00f3ry mo\u017cesz srogo zap\u0142aci\u0107.<\/p>\n

Tyle teorii. Pora na praktyk\u0119.<\/p>\n

Stos – definicja struktury przechowuj\u0105cej dane<\/strong><\/h1>\n

Struktura przechowuj\u0105ca dane naszego stosu b\u0119dzie bardzo prosta. Nie masz si\u0119 czego ba\u0107. Zreszt\u0105 i tak om\u00f3wimy j\u0105 krok po kroku. Sp\u00f3jrz na poni\u017cszy listing:<\/p>\n

struct stack_node\r\n{\r\n    int data;\r\n    struct stack_node* next;\r\n};\r\n<\/pre>\n
Zwyczajna struktura, co nie? W trzeciej linijce utworzyli\u015bmy sobie zwyczajn\u0105 zmienn\u0105 typu integer o nazwie data. Na podstawie tego mo\u017cesz domy\u015bli\u0107 si\u0119, \u017ce nasz stos b\u0119dzie przechowywa\u0142 liczby. Oczywi\u015bcie, stos mo\u017ce przechowywa\u0107 dowolne typy danych. Ale dla uproszczenia przyjmijmy, \u017ce b\u0119d\u0105 to w\u0142a\u015bnie liczby ca\u0142kowite.<\/p>\n
Tajemnie wygl\u0105da czwarta linijka. Jest to wska\u017anik na struktur\u0119 typu, kt\u00f3r\u0105 w\u0142a\u015bnie tworzymy o nazwie next? Co to jest? Wygl\u0105da, jak niby-rekurencja. W istocie, mo\u017cna to tak potraktowa\u0107. Wska\u017anik next przechowuje adres elementu, kt\u00f3ry znajduje si\u0119 o jeden stopie\u0144 „ni\u017aej” w tej strukturze. Je\u015bli omawiamy element znajduj\u0105cy si\u0119 na samym dnie, to wska\u017anik next b\u0119dzie mia\u0142 warto\u015b\u0107 NULL. Jak sobie to wyobrazi\u0107 w rzeczywisto\u015bci? Talerz znajduj\u0105cy si\u0119 na szczycie, dotyka swoj\u0105 powierzchni\u0105 talerza znajduj\u0105cego si\u0119 pod spodem. I to talerz i to talerz, a wi\u0119c mie\u015bci si\u0119 to w definicji struktury stack_node. Ten „dotyk” mo\u017cemy wyobrazi\u0107 sobie jako wska\u017anik next. Talerz znajduj\u0105cy si\u0119 na samym dnie stosu dotyka sto\u0142u. St\u00f3\u0142 nie jest talerzem a wi\u0119c wska\u017anik ten przyjmie warto\u015b\u0107 NULL.<\/p>\n
Dzi\u0119ki temu, \u017ce wska\u017anik next mo\u017ce by\u0107 NULL-em mo\u017cemy bardzo \u0142atwo rozpozna\u0107 ostatni element stosu. Tylko egzemplarz struktury znajduj\u0105cy si\u0119 na dnie stosu b\u0119dzie mia\u0142 w polu next warto\u015b\u0107 NULL.<\/p>\n
Stos – funkcje push, pop, peek<\/strong><\/h1>\n
Stos – push<\/h2>\n
 \r\nstruct stack_node *push(struct stack_node* top, int number)\r\n{\r\n    struct stack_node* new_node = NULL;\r\n    new_node = (struct stack_node*) malloc(sizeof(struct stack_node));\r\n     if(new_node!=NULL)\r\n     {\r\n          new_node->data = number;\r\n          new_node->next = top;\r\n          top = new_node;\r\n     }\r\n     return top;\r\n}\r\n<\/pre>\n
Pierwsza z funkcji, kt\u00f3re om\u00f3wimy dodaje na szczyt stosu kolejny element. Jest ona prosta, jak wszystko w informatyce \ud83d\ude42 Niemniej, om\u00f3wimy j\u0105 linijka po linijce (no, prawie – oczywiste rzeczy pominiemy \ud83d\ude42<\/p>\n
Najpierw przeanalizujmy definicj\u0119 naszej funkcji. Zwraca ona element typu wska\u017anik na stack_node. Jako argumenty przyjmujemy wska\u017anik na szczyt stosu oraz warto\u015b\u0107 liczbow\u0105, jak\u0105 zapiszemy w nowym elemencie.<\/p>\n
W trzeciej linijce tworzymy sobie wska\u017anik na stack_node. stack_node, jak pami\u0119tamy, przechowuje pojedynczy element (talerz) naszego stosu. Na pocz\u0105tku temu wska\u017anikowi przypisujemy warto\u015b\u0107 NULL. Oznacza to, \u017ce ten element tak w\u0142a\u015bciwie nie istnieje. Dzieje si\u0119 tak, gdy\u017c dopiero go tworzymy.<\/p>\n
W linijce czwartej dziej\u0105 si\u0119 prawdziwe cuda. Przydzielamy pami\u0119\u0107 dla naszego nowo_utworzonego wska\u017anika new_node. To co znajduje si\u0119 tu\u017c po znaku =, w nawiasach, to rzutowanie. M\u00f3wimy kompilatorowi, \u017ce pami\u0119\u0107, kt\u00f3r\u0105 w\u0142a\u015bnie przydzieli\u0142 to jest pami\u0119\u0107 dla elementu typu stack_node. Oczywi\u015bcie, kompilator mo\u017ce si\u0119 domy\u015bli\u0107 takiej oczywisto\u015bci, ale nie radzi\u0142 bym na tym polega\u0107. Po rzutowaniu znajduje si\u0119 standardowe wywo\u0142anie funkcji malloc. W nawiasie podali\u015bmy, ile bajt\u00f3w musimy zarezerwowa\u0107. Nie znamy rozmiaru naszej struktury, ale zna j\u0105 operator sizeof, z kt\u00f3rego w tym momencie skrz\u0119tnie korzystamy.<\/p>\n
Pi\u0105ta linijka nie powinna by\u0107 trudna do rozszyfrowania. Sprawdzamy, system operacyjny przydzieli\u0142 pami\u0119\u0107 dla nowego elementu naszego stosu. Je\u015bli tak si\u0119 sta\u0142o, wykonujemy zawarto\u015b\u0107 naszego warunku. Je\u015bli nie – w\u0142a\u015bciwie ko\u0144czymy funkcj\u0119.<\/p>\n
W si\u00f3dmej linijce do nowo utworzonego elementu stosu zapisujemy informacj\u0119, kt\u00f3r\u0105 chcemy przechowywa\u0107. Znacznie ciekawsza jest \u00f3sma dziewi\u0105ta linijka. Co robimy w \u00f3smej? Do pola next nowo utworzonego elementu zapisujemy wska\u017anik na aktualny wierzcho\u0142ek stosu. Dlaczego tak si\u0119 dzieje? Analogicznie do stosu talerzy. Je\u015bli na naszym stosie znajduj\u0105 si\u0119 trzy talerze, to wska\u017anik top b\u0119dzie wskazywa\u0142 na ten trzeci, znajduj\u0105cy si\u0119 na samym szczycie. Je\u015bli w tym momencie do\u0142o\u017cymy czwarty talerz, to wska\u017anik top musi wskazywa\u0107 na nowo do\u0142o\u017cony talerz. Natomiast ten dodany talerz musi wiedzie\u0107, \u017ce pod nim znajduje si\u0119 „by\u0142y” wierzcho\u0142ek stosu, czyli top.<\/p>\n
W dziewi\u0105tej linijce robimy to, co powy\u017cej opisa\u0142em. Zast\u0119pujemy warto\u015b\u0107 aktualnego szczytu stosu nowym elementem.<\/p>\n
W 11 linijce zwracamy nowy wierzcho\u0142ek stosu. Mo\u017cesz zada\u0107 pytanie, po co, skoro do funkcji przekazujemy top jako wska\u017anik, kt\u00f3ry modyfikujemy w linijce dziewi\u0105tej? Pozostawiam te przemy\u015blenia jako prac\u0119 domow\u0105. Wyja\u015bni\u0119 to w jednym z przysz\u0142ych artyku\u0142\u00f3w (je\u015bli go stworz\u0119, w tym miejscu pojawi si\u0119 link do niego).<\/p>\n
Stos – pop<\/h2>\n
Skoro umie\u015bcimy jakie\u015b elementy na stosie, to musimy umie\u0107 r\u00f3wnie\u017c je zdj\u0105\u0107. Nie ma co ukrywa\u0107, funkcja pop jest nieco bardziej skomplikowana. Ale tylko troszeczk\u0119, nie masz si\u0119 czym przejmowa\u0107 xD<\/p>\n
int pop(struct stack_node **top)\r\n{\r\n     int result = -1;\r\n     if(*top!=NULL)\r\n     {\r\n          result = (*top)->data;\r\n          struct stack_node *tmp = (*top)->next;\r\n          free(*top);\r\n          *top = tmp;\r\n     }\r\n     return result;\r\n}\r\n<\/pre>\n
Nie taki diabe\u0142 straszny, jak go maluj\u0105. Poradzimy sobie z om\u00f3wieniem tej funkcji.<\/p>\n
Najpierw, standardowo, definicja. Funkcja zwraca warto\u015b\u0107 typu int. Jako argument przyjmujemy podw\u00f3jny (COO?) wska\u017anik na wierzcho\u0142ek stosu.<\/p>\n
Dlaczego podw\u00f3jny? Aby\u015bmy go mogli zmodyfikowa\u0107 wewn\u0105trz funkcji. Wi\u0119cej szczeg\u00f3\u0142\u00f3w na ten temat niebawem.<\/p>\n
W trzeciej linijce tworzymy sobie now\u0105 zmienn\u0105 int. W niej b\u0119dziemy przechowywali wynik dzia\u0142ania naszej funkcji. Domy\u015blnie b\u0119dziemy zwracali -1. Zak\u0142adamy wi\u0119c, \u017ce w naszym stosie b\u0119dziemy przechowywali tylko i wy\u0142\u0105cznie liczby nieujemne.<\/p>\n
Czwarta linijka stanowi zabezpieczenie przed tym, aby\u015bmy przypadkiem nie pr\u00f3bowali usuwa\u0107 elementu z pustego stosu. Wierzcho\u0142ek pustego stosu b\u0119dzie po prostu NULL-em, kt\u00f3rego wy\u0142apie ten warunek. W przeciwnym wypadku, gdy na stosie znajduj\u0105 si\u0119 jakie\u015b elementy, musimy nieco bardziej si\u0119 natrudzi\u0107.<\/p>\n
W sz\u00f3stej linijce pobieramy zawarto\u015b\u0107 aktualnego wierzcho\u0142ka stosu do zmiennej result. Musimy pami\u0119ta\u0107 o dodatkowej gwiazdce i nawiasach. Jako argument przyj\u0119li\u015bmy podw\u00f3jny wska\u017anik na zmienn\u0105 wierzcho\u0142ka stosu. Strza\u0142ka wykonuje nam tak jakby jedynie jedn\u0105 dereferencj\u0119, a my musimy wykona\u0107 a\u017c dwie. W\u0142a\u015bnie dlatego musimy zastosowa\u0107 taki dziwny zapis.<\/p>\n
W si\u00f3dmej linijce tworzymy sobie wska\u017anik na struktur\u0119 stack_node o nazwie tmp i zapisujemy do niego wska\u017anik na element stosu znajduj\u0105cy si\u0119 poni\u017cej top. Dlaczego? To proste – musimy wiedzie\u0107, jaki b\u0119dzie nasz nast\u0119pny wierzcho\u0142ek, po usuni\u0119ciu aktualnego elementu znajduj\u0105cego si\u0119 na szczycie.<\/p>\n
A co, je\u015bli usuwamy w\u0142a\u015bnie ostatni element? Wtedy we wska\u017aniku next->; b\u0119dzie znajdowa\u0142 si\u0119 NULL. Je\u015bli ten NULL przypiszemy do wska\u017anika na wierzcho\u0142ek stosu (co czynimy w linijce dziewi\u0105tej) to jednoznacznie poinformujemy programist\u0119 korzystaj\u0105cego z naszego stosu \u017ce jest on pusty.<\/p>\n
W \u00f3smej linijce zwalniamy pami\u0119\u0107. Porz\u0105dny programista powinien po sobie sprz\u0105ta\u0107 i w\u0142a\u015bnie to w tym miejscu robimy.<\/p>\n
O dziewi\u0105tej linijce wspomina\u0142em ju\u017c wcze\u015bniej. Zapisujemy w niej wska\u017anik na nowy wierzcho\u0142ek stosu. Zmiana ta b\u0119dzie widoczna na zewn\u0105trz funkcji.<\/p>\n
Linijka 11 to tylko formalno\u015b\u0107. Zwracamy warto\u015b\u0107 zmiennej result, czyli to, co znajdowa\u0142o si\u0119 w aktualnym elemencie stosu.<\/p>\n
Stos – peek<\/h2>\n
Zosta\u0142a nam do wykonania ostatnia funkcja. Co b\u0119dzie robi\u0142o peek? To samo co pop, ale bez zdejmowania znajduj\u0105cego si\u0119 na szczycie elementu ze stosu. Po prostu, czasem istnieje potrzeba przeczytania zawarto\u015bci tego, co znajduje si\u0119 na szczycie bez zdejmowania tego. Np.: Chcemy zobaczy\u0107, jak brudny jest talerz po wczorajszym obiedzie, ale nie chce nam si\u0119 w chwili obecnej tego zmywa\u0107 \ud83d\ude42 Bez funkcji peek by\u0142oby to niemo\u017cliwe xD<\/p>\n
int peek(struct stack_node *top)\r\n{\r\n     if(top!=NULL) return top->data; \r\n     else return -1;\r\n}\r\n<\/pre>\n
Chyba ju\u017c wiesz, \u017ce jest to funkcja najprostsza z ca\u0142ej tr\u00f3jki \ud83d\ude42 Mimo wszystko, om\u00f3wimy j\u0105, cho\u0107 nie powiniene\u015b mie\u0107 problemu z samodzieln\u0105 interpretacj\u0105.<\/p>\n
Definicja – zwracamy liczb\u0119 typu int, czyli to, co znajduje si\u0119 na szczycie stosu. Jako argument przyjmujemy pojedynczy wska\u017anik na struktur\u0119 stack_node przechowuj\u0105c\u0105 wierzcho\u0142ek naszego stosu.<\/p>\n
W trzeciej linijce sprawdzamy, czy nasz stos przypadkiem nie jest pusty. Je\u015bli nie jest, to zwracamy zawarto\u015b\u0107 pola data tego, co znajduje si\u0119 na szczycie. W przeciwnym wypadku zwracamy -1 (wcze\u015bniej przyj\u0119li\u015bmy, \u017ce oznacza to albo b\u0142\u0105d, albo pustot\u0119 naszego stosu).<\/p>\n
No i to prawie wszystko. Zosta\u0142o pokaza\u0107 ci, m\u00f3j drogi czytelniku, jak u\u017cywa\u0107 stworzonego przed chwil\u0105 stosu.<\/p>\n
Funkcja main – czyli jak u\u017cywa\u0107 stworzonego stosu?<\/h2>\n
int main()\r\n{\r\n    struct stack_node* our_stack = NULL;\r\n    for(int i = 10;i>0;i--)\r\n    {\r\n        our_stack = push(our_stack,i);\r\n        printf(\"Klade element %d na stos\\n\",i);\r\n    }\r\n    printf(\"\\nCzytam element na szczycie bez zdejmowania. Ma on wartosc: %d\\n\",peek(our_stack));\r\n    while(our_stack!=NULL)\r\n    {\r\n        printf(\"Zdejmuje element %d ze stosu\\n\",pop(&our_stack));\r\n    }\r\n    return 0; \r\n}\r\n<\/pre>\n
Co robimy? W trzeciej linijce tworzymy sobie wska\u017anik na wierzcho\u0142ek stosu. Przypisujemy mu warto\u015b\u0107 NULL co oznacza, \u017ce stos jest pusty. (Pami\u0119taj – zawsze przypisuj wska\u017anikowi na wierzcho\u0142ek pustego stosu warto\u015b\u0107 NULL – inaczej ca\u0142a ta konstrukcja nie b\u0119dzie prawid\u0142owo dzia\u0142a\u0107) .
\nW czwartej linijce znajduje si\u0119 p\u0119tla for, wewn\u0105trz kt\u00f3rej dodajemy dziesi\u0119\u0107 element\u00f3w na stos w porz\u0105dku malej\u0105cym. W sz\u00f3stej linijce dodajemy element na szczyt naszego stosu. W si\u00f3dmej wypisujemy sobie, jaki element w\u0142a\u015bnie dodali\u015bmy.
\nW linijce dziewi\u0105tej robimy u\u017cytek z funkcji peek. Odczytujemy, co przechowuje element na szczycie stosu bez zdejmowania go.
\nW dziesi\u0105tej linijce znajduje si\u0119 p\u0119tla while. Robimy u\u017cytek z tego, \u017ce NULL wskazuje na koniec stosu. Przeszukujemy stos do momentu, w kt\u00f3rym wierzcho\u0142ek nie b\u0119dzie wskazywa\u0142 na NULL. W linijce dwunastej zdejmujemy element ze szczytu stosu. Wypisujemy tak\u017ce jego warto\u015b\u0107.<\/p>\n
\"efekt_stosu\"
Efekt dzia\u0142ania naszego stosu<\/figcaption><\/figure>\n
To tyle. Mam nadziej\u0119, \u017ce wszystko zrozumia\u0142e\u015b \ud83d\ude42 Je\u015bli masz jakie\u015b pytania, pisz w prywatnej wiadomo\u015bci na Fanpage’u lub na adres email podany na samej g\u00f3rze. Mo\u017cesz tak\u017ce napisa\u0107 komentarz.
\nJe\u015bli ci si\u0119 podoba\u0142o, pami\u0119taj o polubieniu mojego Fanpage’a. Dzi\u0119ki temu b\u0119dziesz na bie\u017c\u0105co z nowymi artyku\u0142ami. A ja b\u0119d\u0119 szcz\u0119\u015bliwy maj\u0105c kolejnego sta\u0142ego czytelnika \ud83d\ude42
\nKod wy\u017cej omawianego programu znajduje si\u0119 w moim repozytorium. <\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Czas czytania:<\/span> 7<\/span> minut<\/span><\/span> Stos jest najprostsz\u0105 dynamiczn\u0105 struktur\u0105 danych. A w zwi\u0105zku z tym b\u0119dzie to tak\u017ce pierwsza dynamiczna struktura danych, kt\u00f3r\u0105 poznasz. Najpierw wyja\u015bnijmy, co to s\u0105 te dynamiczne struktury danych? Dynamiczna …<\/p>\n","protected":false},"author":1,"featured_media":174,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[25,22],"tags":[],"_links":{"self":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/168"}],"collection":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/comments?post=168"}],"version-history":[{"count":7,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/168\/revisions"}],"predecessor-version":[{"id":223,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/posts\/168\/revisions\/223"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/media\/174"}],"wp:attachment":[{"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/media?parent=168"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/categories?post=168"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kompikownia.pl\/index.php\/wp-json\/wp\/v2\/tags?post=168"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}