API tools faq
paste
Sanady

C++ Domaca

Sanady
Oct 6th, 2019
306
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 12.63 KB | None | 0 0
raw download clone embed print report
  1. /*
  2. Meno a priezvisko:
  3.  
  4. POKYNY:
  5. (1)  Subor premenujte na Priezvisko_Meno_ID_du02.cpp (pouzite vase udaje bez diakritiky).
  6. (2)  Implementujte funkcie tak, aby splnali popis pri ich deklaraciach.
  7. (3)  Cela implementacia musi byt v tomto jednom subore.
  8. (4)  Odovzdajte len tento (spravne premenovany) zdrojovy subor.
  9. (5)  Program musi byt kompilovatelny.
  10. (6)  Globalne a staticke premenne su zakazane.
  11. (7)  V ziadnom pripade nemente deklaracie funkcii, ktore mate za ulohu naprogramovat
  12. (nemente nazvy, navratove hodnoty ani typ a pocet parametrov v zadanych funkciach).
  13. Nemente implementacie hotovych pomocnych funkcii, ani implementacie zadanych datovych typov.
  14. (8)  V pripade potreby mozete kod doplnit o dalsie pomocne funkcie alebo struktury.
  15. (9)  Vase riesenie otestujte (vo funkcii 'main' a pomocou doplnenych pomocnych funkcii alebo struktur).
  16. Testovaci kod ale nebude hodnoteny.
  17. (10) Funkcia 'main' musi byt v zdrojovom kode posledna.
  18. */
  19.  
  20. #include <iostream>
  21.  
  22. using namespace std;
  23.  
  24. //-------------------------------------------------------------------------------------------------
  25. // DATOVE TYPY
  26. //-------------------------------------------------------------------------------------------------
  27.  
  28. // Reprezentacia uzla zretazeneho zoznamu
  29. struct Node {
  30.     int data; // hodnota uzla
  31.     Node* next; // adresa nasledujuceho uzla zoznamu
  32. };
  33.  
  34. // Reprezentacia zretazeneho zoznamu
  35. struct List {
  36.     Node* first; // adresa prveho uzla zoznamu
  37. };
  38.  
  39. // Uspesnost vykonania funkcie
  40. enum class Result {
  41.     SUCCESS, // funkcia vykonana uspesne
  42.     FAILURE  // chyba pri vykonavani funkcie
  43. };
  44.  
  45.  
  46. //-------------------------------------------------------------------------------------------------
  47. // ULOHA c.1 (0.1 boda)
  48. //-------------------------------------------------------------------------------------------------
  49. /*
  50. Funkcia prida novy uzol s hodnotou 'val' na zaciatok zoznamu 'list'.
  51.  
  52. PARAMETRE:
  53. [in] list - vstupny zretazeny zoznam
  54. [in] val - hodnota uzla pridaneho na zaciatok zoznamu
  55.  
  56. PRIKLADY:
  57. list={} a val=0 ... zoznam po vykonani funkcie ... {0}
  58. list={-3} a val=1 ... zoznam po vykonani funkcie ... {1,-3}
  59. list={6,6,6,8} a val=10 ... zoznam po vykonani funkcie ... {10,6,6,6,8}
  60. */
  61.  
  62. void prependNode(List* list, const int val) {
  63.     Node* newNode = new Node;
  64.     newNode->data = val;
  65.     newNode->next = list->first;
  66.     list->first = newNode;
  67.  
  68. }
  69.  
  70. //-------------------------------------------------------------------------------------------------
  71. // ULOHA c.2 (0.1 boda)
  72. //-------------------------------------------------------------------------------------------------
  73. /*
  74. Funkcia prida novy uzol s hodnotou 'val' na koniec zoznamu 'list'.
  75.  
  76. PARAMETRE:
  77. [in] list - vstupny zretazeny zoznam
  78. [in] val - hodnota uzla pridaneho na koniec zoznamu
  79.  
  80. PRIKLADY:
  81. list={} a val=7 ... zoznam po vykonani funkcie ... {7}
  82. list={0} a val=1 ... zoznam po vykonani funkcie ... {0,1}
  83. list={1,2,3,4,5} a val=6 ... zoznam po vykonani funkcie ... {1,2,3,4,5,6}
  84. */
  85.  
  86. void appendNode(List* list, const int val) {
  87.     Node* newNode = new Node;
  88.     newNode->data = val;
  89.     newNode->next = nullptr;
  90.     if (list->first) {
  91.         Node* tmp = list->first;
  92.         while (tmp->next)
  93.         {
  94.             tmp = tmp->next;
  95.         }
  96.         tmp->next = newNode;
  97.     }
  98.     else
  99.     {
  100.         list->first = newNode;
  101.     }
  102. }
  103.  
  104. //-------------------------------------------------------------------------------------------------
  105. // ULOHA c.3 (0.1 boda)
  106. //-------------------------------------------------------------------------------------------------
  107. /*
  108. Funkcia vytvori novy zretazeny zoznam a vyplni ho vsetkymi cislami (v zachovanom poradi),
  109. ktore sa nachadzaju vo vstupnom poli 'data', ktore ma dlzku 'n'.
  110.  
  111. PARAMETRE:
  112. [in] data - vstupne pole cisiel
  113. [in] n - dlzka vstupneho pola
  114.  
  115. RETURN:
  116. Vytvoreny zretazeny zoznam obsahujuci vsetky hodnoty zo vstupneho pola 'data' (v zachovanom poradi).
  117. V pripade prazdneho pola (dlzka 0), funkcia vrati prazdny zoznam (prazdny zoznam je taky, kde smernik 'first'
  118. ukazuje na 'nullptr'). V pripade neplatnej dlzky (ak je parameter 'n' zaporny), funkcia vrati 'nullptr'.
  119. PRIKLADY:
  120. data={1} a n=1 ... vrati zoznam ... {1}
  121. data={7,6,41,2} a n=4 ... vrati zoznam ... {7,6,41,2}
  122. data={3,2,1} a n=0 ... vrati zoznam ... {}
  123. data={6,3,9,10} a n=-7 ... vrati ... 'nullptr'
  124. */
  125.  
  126. List* createListFromArray(const int* data, const int n) {
  127.  
  128.  
  129.     return nullptr; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  130. }
  131.  
  132. //-------------------------------------------------------------------------------------------------
  133. // ULOHA c.4 (0.1 boda)
  134. //-------------------------------------------------------------------------------------------------
  135. /*
  136. Funkcia vytvori novy symetricky zretazeny zoznam (vid priklady) podla parametra 'val'. Symetricky zoznam ma
  137. tvar 0,1,2,...val...2,1,0.
  138.  
  139. PARAMETRE:
  140. [in] val - hodnota uzla podla, ktoreho sa vytvori novy symetricky zretazeny zoznam (uzol v strede zoznamu).
  141.  
  142. RETURN:
  143. Vytvoreny zretazeny zoznam obsahujuci prvky v takom poradi, aby bol symetricky. V pripade 'val'<0, funkcia vrati
  144. 'nullptr'.
  145.  
  146. PRIKLADY:
  147. val=-31 ... vrati ... nullptr
  148. val=0 ... vrati zoznam ... {0}
  149. val=1 ... vrati zoznam ... {0,1,0}
  150. val=2 ... vrati zoznam ... {0,1,2,1,0}
  151. val=3 ... vrati zoznam ... {0,1,2,3,2,1,0}
  152. val=4 ... vrati zoznam ... {0,1,2,3,4,3,2,1,0}
  153. val=6 ... vrati zoznam ... {0,1,2,3,4,5,6,5,4,3,2,1,0}
  154. */
  155.  
  156. List* createSymmetricList(const int val) {
  157.     // TODO
  158.     return nullptr; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  159. }
  160.  
  161.  
  162. //-------------------------------------------------------------------------------------------------
  163. // ULOHA c.5 (0.1 boda)
  164. //-------------------------------------------------------------------------------------------------
  165. /*
  166. Funkcia odstrani (aj spravne uvolni pamat) zo vstupneho zoznamu 'list' prvy uzol.
  167.  
  168. PARAMETRE:
  169. [in,out] list - vstupny zretazeny zoznam
  170.  
  171. RETURN:
  172. Result::SUCCESS, ak bol prvy uzol vymazany
  173. Result::FAILURE, ak nebol prvy uzol vymazany (vstupny zoznam bol prazdny)
  174.  
  175. PRIKLADY:
  176. list={} ... funkcia vrati Result::FAILURE
  177. list={5} ... zoznam po vykonani funkcie ... {} a vrati Result::SUCCESS
  178. list={10,10,10} ... zoznam po vykonani funkcie ... {10,10} a vrati Result::SUCCESS
  179. list={3,2,1} ... zoznam po vykonani funkcie ... {2,1} a vrati Result::SUCCESS
  180. */
  181.  
  182. Result removeFirstNode(List* list) {
  183.     if (list->first) {
  184.         Node* tmp = list->first->next;
  185.         delete list->first;
  186.         list->first = tmp;
  187.     }
  188.  
  189.  
  190.     return Result::FAILURE; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  191. }
  192.  
  193. void removeLastNode(List* list) {
  194.     if (list->first) {
  195.         Node* tmp = list->first;
  196.         Node* prev = nullptr;
  197.         while (tmp->next) {
  198.             prev = tmp;
  199.             tmp = tmp->next;
  200.         }
  201.         if (!prev) {
  202.             list->first = nullptr;
  203.         }
  204.         else
  205.         {
  206.             prev->next = nullptr;
  207.         }
  208.         delete tmp;
  209.  
  210.     }
  211. }
  212.  
  213. //-------------------------------------------------------------------------------------------------
  214. // ULOHA c.6 (0.1 boda)
  215. //-------------------------------------------------------------------------------------------------
  216. /*
  217. Funkcia najde prvy uzol zretazeneho zoznamu 'list', ktory obsahuje hodnotu 'val'.
  218.  
  219. PARAMETRE:
  220. [in] list - vstupny zretazeny zoznam
  221. [in] val - hodnota uzla, ktory sa hlada
  222.  
  223. RETURN:
  224. Funkcia vrati prvy uzol, ktory obsahuje hodnotu 'val'. Ak sa taky uzol v zozname nenachadza alebo je vstupny
  225. zoznam prazdny, vtedy funkcia vrati 'nullptr'.
  226.  
  227. PRIKLADY:
  228. list={}, val=10 ... funkcia vrati 'nullptr'
  229. list={2}, val=3 ... funkcia vrati 'nullptr'
  230. list={1,2,3,4,5,6}, val=-1 ... funkcia vrati 'nullptr'
  231. list={1}, val=1 ... funkcia vrati uzol s hodnotou 1
  232. list={5,9,18}, val=9 ... funkcia vrati uzol s hodnotou 9
  233. */
  234.  
  235. Node* findNodeInList(List* list, const int val) {
  236.     Node* tmp = list->first;
  237.     while (tmp)
  238.     {
  239.         if (tmp->data == val) {
  240.             break;
  241.         }
  242.         tmp = tmp->next;
  243.     }
  244.     return tmp; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  245. }
  246. //-------------------------------------------------------------------------------------------------
  247. // ULOHA c.7 (0.1 boda)
  248. //-------------------------------------------------------------------------------------------------
  249. /*
  250. Funkcia zisti, ci su dva vstupne zoznamy 'list1' a 'list2' rovnake (t.j. rovnako dlhe a obsahujuce
  251. rovnake hodnoty uzlov v rovnakom poradi).
  252.  
  253. PARAMETRE:
  254. [in] list1 - prvy zretazeny zoznam
  255. [in] list2 - druhy zretazeny zoznam
  256.  
  257. RETURN:
  258. 'true' - ak su vstupne zoznamy rovnake
  259. 'false' - ak vstupne zoznamy nie su rovnake
  260.  
  261. PRIKLADY:
  262. list1={1}
  263. list2={}
  264. Funkcia vrati 'false'.
  265.  
  266. list1={}
  267. list2={5,3}
  268. Funkcia vrati 'false'.
  269.  
  270. list1={}
  271. list2={}
  272. Funkcia vrati 'true'.
  273.  
  274. list1={1}
  275. list2={1}
  276. Funkcia vrati 'true'.
  277.  
  278. list1={4,-9,2}
  279. list2={4,-9,2}
  280. Funkcia vrati 'true'.
  281.  
  282. list1={3,2,1}
  283. list2={1,2,3}
  284. Funkcia vrati 'false'.
  285.  
  286. list1={2}
  287. list2={7,4,5}
  288. Funkcia vrati 'false'.
  289. */
  290.  
  291. bool areListsEqual(List* list1, List* list2) {
  292.     Node* Node1 = new Node;
  293.     Node* Node2 = new Node;
  294.     if (list1->first == list2->first)
  295.     {
  296.         while (Node1->next && Node2->next)
  297.         {
  298.             if (Node1->data != Node2->data)
  299.             {
  300.                 return false;
  301.             }
  302.         }
  303.     }
  304.     return true; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  305. }
  306.  
  307.  
  308. //-------------------------------------------------------------------------------------------------
  309. // ULOHA c.8 (0.1 boda)
  310. //-------------------------------------------------------------------------------------------------
  311. /*
  312. Funkcia vytvori novy zretazeny zoznam prekopirovanim vsetkych hodnot uzlov vstupneho zoznamu 'list' v obratenom
  313. poradi.
  314.  
  315. PARAMETRE:
  316. [in] list - vstupny zretazeny zoznam
  317.  
  318. RETURN:
  319. Zretazeny oznam, ktory vznikne prekopirovanim hodnot uzlov vstupneho zoznamu 'list' v obratenom poradi.
  320.  
  321. PRIKLADY:
  322. list={} ... funkcia vrati ... {} t.j. prazdny zoznam
  323. list={1} ... funkcia vrati ... {1}
  324. list={5,6} ... funkcia vrati ... {6,5}
  325. list={8,14,2,3} ... funkcia vrati ... {3,2,14,8}
  326. */
  327.  
  328. List* copyListReverse(List* list) {
  329.     // TODO
  330.     return nullptr; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  331. }
  332.  
  333. //-------------------------------------------------------------------------------------------------
  334. // ULOHA c.9 (0.1 boda)
  335. //-------------------------------------------------------------------------------------------------
  336. /*
  337. Funkcia vyhlada predchodcu zadaneho uzla 'node' vo vstupnom zretazenom zozname 'list'. Uzol 'node' je vzdy
  338. existujucim uzlom vstupneho zoznamu 'list'.
  339.  
  340. PARAMETRE:
  341. [in] list - vstupny zretazeny zoznam
  342. [in] node - uzol zretazeneho zoznamu 'list', ktoreho predchodcu hladame
  343.  
  344. RETURN:
  345. Uzol, ktory je predchodcom uzla 'node' v zozname 'list'. V pripade hladania predchodcu prveho uzla zoznamu,
  346. funkcia vrati 'nullptr'.
  347.  
  348. PRIKLADY:
  349. list={4}
  350. node=4
  351. Funkcia vrati 'nullptr'.
  352.  
  353. list={1,2,3,4,5}
  354. node=1
  355. Funkcia vrati 'nullptr'.
  356.  
  357. list={-2,-3,56,4,41}
  358. node=-3
  359. Funkcia vrati uzol s hodnotou -2.
  360.  
  361. list={10,54,69,82,6}
  362. node=6
  363. Funkcia vrati uzol s hodnotou 82.
  364. */
  365.  
  366. Node* findPreviousNode(List* list, Node* node) {
  367.     // TODO
  368.     return nullptr; // tento riadok zmente podla zadania, je tu len kvoli kompilacii
  369. }
  370.  
  371. //-------------------------------------------------------------------------------------------------
  372. // ULOHA c.10 (0.1 boda)
  373. //-------------------------------------------------------------------------------------------------
  374. /*
  375. Funkcia zduplikuje vsetky uzly vstupneho zoznamu 'list', ktore obsahuju kladnu hodnotu.
  376.  
  377. PARAMETRE:
  378. [in,out] list - vstupny zretazeny zoznam
  379.  
  380. PRIKLADY:
  381. list={} ... po vykonani funkcie ... {}
  382. list={3} ... po vykonani funkcie ... {3,3}
  383. list={-1,1} ... po vykonani funkcie ... {-1,1,1}
  384. list={-8,-9,-13} ... po vykonani funkcie ... {-8,-9,-13}
  385. list={1,0,-2,3,-4} ... po vykonani funkcie ... {1,1,0,-2,3,3,-4}
  386. */
  387.  
  388. void duplicatePositiveNodes(List* list) {
  389.     Node* tmp = list->first;
  390.     while (tmp->next)
  391.     {
  392.         if (tmp->data > 0)
  393.         {
  394.             tmp = tmp->next;
  395.         }
  396.     }
  397. }
  398.  
  399. void clearList(List* list) {
  400.     while (list->first)
  401.     {
  402.         Node* tmp = list->first->next;
  403.         delete list->first;
  404.         list->first = tmp;
  405.     }
  406. }
  407.  
  408. void destroyList(List** list) {
  409.     clearList(*list);
  410.     delete* list;
  411.     *list = nullptr;
  412. }
  413.  
  414. //-------------------------------------------------------------------------------------------------
  415. // TESTOVANIE
  416. //-------------------------------------------------------------------------------------------------
  417.  
  418. // tu mozete doplnit pomocne funkcie a struktury
  419. int main(int argc, char** argv) {
  420.     List* list = new List;
  421.     list->first = nullptr;
  422.  
  423.     for (int i = 0; i < 5; i++) {
  424.         prependNode(list, i);
  425.         cout << i << endl;
  426.     }
  427.  
  428.     cout << "===================================" << endl;
  429.  
  430.     for (int i = 0; i < 5; i++) {
  431.         appendNode(list, i);
  432.         cout << i << endl;
  433.     }
  434.  
  435.     //removeFirstNode(list);
  436.     //removeLastNode(list);
  437.     destroyList(&list);
  438.     //printList(list);
  439.  
  440.  
  441.  
  442.     cin.get();
  443.     system("PAUSE");
  444.     return 0;
  445. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!