API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 24th, 2018
97
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 76.03 KB | None | 0 0
raw download clone embed print report
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <windows.h>
  5. #include <stdbool.h>
  6. #include <time.h>
  7.  
  8. double obliczSekundy( clock_t czas )
  9. {
  10.     return  (double)czas / CLOCKS_PER_SEC;
  11. }
  12. struct stack
  13. {
  14.     int przesuniecia;
  15.     int porownania;
  16.  
  17. }staty;
  18.  
  19. struct ksiazka_telefoniczna
  20. {
  21.     int ID;
  22.     char imie[40];
  23.     char nazwisko[40];
  24.  
  25.     char ulica[40];
  26.     char numer_domu[40];
  27.     char miasto[40];
  28.     char kod_pocztowy[40];
  29.  
  30.     //char wojewodztwo[40];
  31.     int numer_telefonu;
  32.     char mail[40];
  33.  
  34.     struct ksiazka_telefoniczna *next,*prev;
  35.  
  36. };
  37.  
  38.  
  39.  
  40. void swap ( int* a, int* b )
  41. {   int t = *a;
  42.     *a = *b;
  43.     *b = t;
  44. }
  45.  
  46. void swap_text( char lancuch1[], char lancuch2[] )
  47. {   char tmp[40];
  48.     strcpy(tmp,lancuch1);
  49.     strcpy(lancuch1,lancuch2);
  50.     strcpy(lancuch2,tmp);
  51.  
  52. }
  53.  
  54.  
  55.  
  56.  
  57.  
  58. struct ksiazka_telefoniczna *lastNode(struct ksiazka_telefoniczna *root)// A utility function to find last node of linked list
  59. {
  60.     while (root && root->next)
  61.         root = root->next;
  62.     return root;
  63. }
  64.  
  65.  
  66.  
  67.  
  68.  
  69. //ID ROSNACO
  70.  
  71. struct ksiazka_telefoniczna* partition(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  72. {
  73.     // set pivot as h element
  74.     int x  = h->ID;
  75.     int por=0;
  76.     int przes=0;
  77.  
  78.     // similar to i = l-1 for array implementation
  79.     struct ksiazka_telefoniczna *i = l->prev;
  80.     struct ksiazka_telefoniczna *j = l;
  81.  
  82.     // Similar to "for (int j = l; j <= h- 1; j++)"
  83.     for (j = l; j != h; j = j->next)
  84.     {
  85.         if (j->ID <= x)
  86.         {
  87.             // Similar to i++ for array
  88.             i = (i == NULL)? l : i->next;
  89.             por+=por+11;
  90.  
  91.             swap(&(i->ID), &(j->ID));
  92.             swap_text((i->imie), (j->imie));
  93.             swap_text((i->nazwisko), (j->nazwisko));
  94.             swap_text((i->ulica), (j->ulica));
  95.             swap_text((i->numer_domu), (j->numer_domu));
  96.             swap_text((i->miasto), (j->miasto));
  97.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  98.             swap_text((i->mail), (j->mail));
  99.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  100.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  101.         }
  102.     }
  103.     i = (i == NULL)? l : i->next; // Similar to i++
  104.     przes+=przes+5;
  105.     swap(&(i->ID), &(j->ID));
  106.     swap_text((i->imie), (j->imie));
  107.     swap_text((i->nazwisko), (j->nazwisko));
  108.     swap_text((i->ulica), (j->ulica));
  109.     swap_text((i->numer_domu), (j->numer_domu));
  110.     swap_text((i->miasto), (j->miasto));
  111.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  112.     swap_text((i->mail), (j->mail));
  113.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  114.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  115.  
  116.     staty.porownania = por;
  117.     staty.przesuniecia = przes;
  118.     return i;
  119. }
  120.  
  121.  
  122. void _quickSort(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  123. {
  124.     if (h != NULL && l != h && l != h->next)
  125.     {
  126.         struct ksiazka_telefoniczna *p = partition(l, h);
  127.         _quickSort(l, p->prev);
  128.         _quickSort(p->next, h);
  129.     }
  130. }
  131.  
  132.  
  133. void quickSort(struct ksiazka_telefoniczna *head)
  134. {
  135.     struct ksiazka_telefoniczna *h = lastNode(head);
  136.     _quickSort(head, h);
  137. }
  138.  
  139. //ID MALEJACO
  140. struct ksiazka_telefoniczna* partition_id_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  141. {
  142.     // set pivot as h element
  143.     int x  = h->ID;
  144.  
  145.     // similar to i = l-1 for array implementation
  146.     struct ksiazka_telefoniczna *i = l->prev;
  147.     struct ksiazka_telefoniczna *j = l;
  148.  
  149.     // Similar to "for (int j = l; j <= h- 1; j++)"
  150.     for (j = l; j != h; j = j->next)
  151.     {
  152.         if (j->ID >= x)
  153.         {
  154.             // Similar to i++ for array
  155.             i = (i == NULL)? l : i->next;
  156.  
  157.             swap(&(i->ID), &(j->ID));
  158.             swap_text((i->imie), (j->imie));
  159.             swap_text((i->nazwisko), (j->nazwisko));
  160.             swap_text((i->ulica), (j->ulica));
  161.             swap_text((i->numer_domu), (j->numer_domu));
  162.             swap_text((i->miasto), (j->miasto));
  163.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  164.             swap_text((i->mail), (j->mail));
  165.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  166.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  167.         }
  168.     }
  169.     i = (i == NULL)? l : i->next; // Similar to i++
  170.     swap(&(i->ID), &(j->ID));
  171.     swap_text((i->imie), (j->imie));
  172.     swap_text((i->nazwisko), (j->nazwisko));
  173.     swap_text((i->ulica), (j->ulica));
  174.     swap_text((i->numer_domu), (j->numer_domu));
  175.     swap_text((i->miasto), (j->miasto));
  176.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  177.     swap_text((i->mail), (j->mail));
  178.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  179.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  180.     return i;
  181. }
  182.  
  183.  
  184. void _quickSort_id_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  185. {
  186.     if (h != NULL && l != h && l != h->next)
  187.     {
  188.         struct ksiazka_telefoniczna *p = partition_id_malejaco(l, h);
  189.         _quickSort_id_malejaco(l, p->prev);
  190.         _quickSort_id_malejaco(p->next, h);
  191.     }
  192. }
  193.  
  194.  
  195. void quickSort_id_malejaco(struct ksiazka_telefoniczna *head)
  196. {
  197.     struct ksiazka_telefoniczna *h = lastNode(head);
  198.     _quickSort_id_malejaco(head, h);
  199. }
  200.  
  201.  
  202.  
  203. //IMIE ROSNACO
  204.  
  205. struct ksiazka_telefoniczna* partition_imie_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  206. {
  207.     // set pivot as h element
  208.     char x[40];
  209.     strcpy(x,h->imie);
  210.  
  211.     // similar to i = l-1 for array implementation
  212.     struct ksiazka_telefoniczna *i = l->prev;
  213.     struct ksiazka_telefoniczna *j = l;
  214.  
  215.     // Similar to "for (int j = l; j <= h- 1; j++)"
  216.     for (j = l; j != h; j = j->next)
  217.     {
  218.         if(strcmp(x,j->imie) == 1 || strcmp(x,j->imie)==0 )//if (j->ID <= x)
  219.         {
  220.             // Similar to i++ for array
  221.             i = (i == NULL)? l : i->next;
  222.  
  223.             swap(&(i->ID), &(j->ID));
  224.             swap_text((i->imie), (j->imie));
  225.             swap_text((i->nazwisko), (j->nazwisko));
  226.             swap_text((i->ulica), (j->ulica));
  227.             swap_text((i->numer_domu), (j->numer_domu));
  228.             swap_text((i->miasto), (j->miasto));
  229.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  230.             swap_text((i->mail), (j->mail));
  231.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  232.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  233.         }
  234.     }
  235.     i = (i == NULL)? l : i->next; // Similar to i++
  236.     swap(&(i->ID), &(j->ID));
  237.     swap_text((i->imie), (j->imie));
  238.     swap_text((i->nazwisko), (j->nazwisko));
  239.     swap_text((i->ulica), (j->ulica));
  240.     swap_text((i->numer_domu), (j->numer_domu));
  241.     swap_text((i->miasto), (j->miasto));
  242.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  243.     swap_text((i->mail), (j->mail));
  244.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  245.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  246.     return i;
  247. }
  248.  
  249.  
  250. void _quickSort_imie_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  251. {
  252.     if (h != NULL && l != h && l != h->next)
  253.     {
  254.         struct ksiazka_telefoniczna *p = partition_imie_rosnaco(l, h);
  255.         _quickSort_imie_rosnaco(l, p->prev);
  256.         _quickSort_imie_rosnaco(p->next, h);
  257.     }
  258. }
  259.  
  260.  
  261. void quickSort_imie_rosnaco(struct ksiazka_telefoniczna *head)
  262. {
  263.     struct ksiazka_telefoniczna *h = lastNode(head);
  264.     _quickSort_imie_rosnaco(head, h);
  265. }
  266.  
  267. //IMIE MALEJACO
  268.  
  269. struct ksiazka_telefoniczna* partition_imie_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  270. {
  271.     // set pivot as h element
  272.     char x[40];
  273.     strcpy(x,h->imie);
  274.  
  275.     // similar to i = l-1 for array implementation
  276.     struct ksiazka_telefoniczna *i = l->prev;
  277.     struct ksiazka_telefoniczna *j = l;
  278.  
  279.     // Similar to "for (int j = l; j <= h- 1; j++)"
  280.     for (j = l; j != h; j = j->next)
  281.     {
  282.         if(strcmp(x,j->imie) == -1 || strcmp(x,j->imie)==0 )//if (j->ID <= x)
  283.         {
  284.             // Similar to i++ for array
  285.             i = (i == NULL)? l : i->next;
  286.  
  287.             swap(&(i->ID), &(j->ID));
  288.             swap_text((i->imie), (j->imie));
  289.             swap_text((i->nazwisko), (j->nazwisko));
  290.             swap_text((i->ulica), (j->ulica));
  291.             swap_text((i->numer_domu), (j->numer_domu));
  292.             swap_text((i->miasto), (j->miasto));
  293.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  294.             swap_text((i->mail), (j->mail));
  295.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  296.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  297.         }
  298.     }
  299.     i = (i == NULL)? l : i->next; // Similar to i++
  300.     swap(&(i->ID), &(j->ID));
  301.     swap_text((i->imie), (j->imie));
  302.     swap_text((i->nazwisko), (j->nazwisko));
  303.     swap_text((i->ulica), (j->ulica));
  304.     swap_text((i->numer_domu), (j->numer_domu));
  305.     swap_text((i->miasto), (j->miasto));
  306.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  307.     swap_text((i->mail), (j->mail));
  308.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  309.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  310.     return i;
  311. }
  312.  
  313.  
  314. void _quickSort_imie_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  315. {
  316.     if (h != NULL && l != h && l != h->next)
  317.     {
  318.         struct ksiazka_telefoniczna *p = partition_imie_malejaco(l, h);
  319.         _quickSort_imie_malejaco(l, p->prev);
  320.         _quickSort_imie_malejaco(p->next, h);
  321.     }
  322. }
  323.  
  324.  
  325. void quickSort_imie_malejaco(struct ksiazka_telefoniczna *head)
  326. {
  327.     struct ksiazka_telefoniczna *h = lastNode(head);
  328.     _quickSort_imie_malejaco(head, h);
  329. }
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.  
  338.  
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352. //NAZWISKO ROSNACO
  353.  
  354. struct ksiazka_telefoniczna* partition_nazwisko_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  355. {
  356.     // set pivot as h element
  357.     char x[40];
  358.     strcpy(x,h->nazwisko);
  359.  
  360.     // similar to i = l-1 for array implementation
  361.     struct ksiazka_telefoniczna *i = l->prev;
  362.     struct ksiazka_telefoniczna *j = l;
  363.  
  364.     // Similar to "for (int j = l; j <= h- 1; j++)"
  365.     for (j = l; j != h; j = j->next)
  366.     {
  367.         if(strcmp(x,j->nazwisko) == 1 || strcmp(x,j->nazwisko)==0 )//if (j->ID <= x)
  368.         {
  369.             // Similar to i++ for array
  370.             i = (i == NULL)? l : i->next;
  371.  
  372.             swap(&(i->ID), &(j->ID));
  373.             swap_text((i->imie), (j->imie));
  374.             swap_text((i->nazwisko), (j->nazwisko));
  375.             swap_text((i->ulica), (j->ulica));
  376.             swap_text((i->numer_domu), (j->numer_domu));
  377.             swap_text((i->miasto), (j->miasto));
  378.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  379.             swap_text((i->mail), (j->mail));
  380.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  381.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  382.         }
  383.     }
  384.     i = (i == NULL)? l : i->next; // Similar to i++
  385.     swap(&(i->ID), &(j->ID));
  386.     swap_text((i->imie), (j->imie));
  387.     swap_text((i->nazwisko), (j->nazwisko));
  388.     swap_text((i->ulica), (j->ulica));
  389.     swap_text((i->numer_domu), (j->numer_domu));
  390.     swap_text((i->miasto), (j->miasto));
  391.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  392.     swap_text((i->mail), (j->mail));
  393.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  394.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  395.     return i;
  396. }
  397.  
  398.  
  399. void _quickSort_nazwisko_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  400. {
  401.     if (h != NULL && l != h && l != h->next)
  402.     {
  403.         struct ksiazka_telefoniczna *p = partition_nazwisko_rosnaco(l, h);
  404.         _quickSort_nazwisko_rosnaco(l, p->prev);
  405.         _quickSort_nazwisko_rosnaco(p->next, h);
  406.     }
  407. }
  408.  
  409.  
  410. void quickSort_nazwisko_rosnaco(struct ksiazka_telefoniczna *head)
  411. {
  412.     struct ksiazka_telefoniczna *h = lastNode(head);
  413.     _quickSort_nazwisko_rosnaco(head, h);
  414. }
  415.  
  416. //NAZWISKO MALEJACO
  417.  
  418. struct ksiazka_telefoniczna* partition_nazwisko_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  419. {
  420.     // set pivot as h element
  421.     char x[40];
  422.     strcpy(x,h->nazwisko);
  423.  
  424.     // similar to i = l-1 for array implementation
  425.     struct ksiazka_telefoniczna *i = l->prev;
  426.     struct ksiazka_telefoniczna *j = l;
  427.  
  428.     // Similar to "for (int j = l; j <= h- 1; j++)"
  429.     for (j = l; j != h; j = j->next)
  430.     {
  431.         if(strcmp(x,j->nazwisko) == -1 || strcmp(x,j->nazwisko)==0 )//if (j->ID <= x)
  432.         {
  433.             // Similar to i++ for array
  434.             i = (i == NULL)? l : i->next;
  435.  
  436.             swap(&(i->ID), &(j->ID));
  437.             swap_text((i->imie), (j->imie));
  438.             swap_text((i->nazwisko), (j->nazwisko));
  439.             swap_text((i->ulica), (j->ulica));
  440.             swap_text((i->numer_domu), (j->numer_domu));
  441.             swap_text((i->miasto), (j->miasto));
  442.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  443.             swap_text((i->mail), (j->mail));
  444.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  445.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  446.         }
  447.     }
  448.     i = (i == NULL)? l : i->next; // Similar to i++
  449.     swap(&(i->ID), &(j->ID));
  450.     swap_text((i->imie), (j->imie));
  451.     swap_text((i->nazwisko), (j->nazwisko));
  452.     swap_text((i->ulica), (j->ulica));
  453.     swap_text((i->numer_domu), (j->numer_domu));
  454.     swap_text((i->miasto), (j->miasto));
  455.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  456.     swap_text((i->mail), (j->mail));
  457.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  458.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  459.     return i;
  460. }
  461.  
  462.  
  463. void _quickSort_nazwisko_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  464. {
  465.     if (h != NULL && l != h && l != h->next)
  466.     {
  467.         struct ksiazka_telefoniczna *p = partition_nazwisko_malejaco(l, h);
  468.         _quickSort_nazwisko_malejaco(l, p->prev);
  469.         _quickSort_nazwisko_malejaco(p->next, h);
  470.     }
  471. }
  472.  
  473.  
  474. void quickSort_nazwisko_malejaco(struct ksiazka_telefoniczna *head)
  475. {
  476.     struct ksiazka_telefoniczna *h = lastNode(head);
  477.     _quickSort_nazwisko_malejaco(head, h);
  478. }
  479.  
  480.  
  481. //ULICA ROSNACO
  482.  
  483. struct ksiazka_telefoniczna* partition_ulica_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  484. {
  485.     // set pivot as h element
  486.     char x[40];
  487.     strcpy(x,h->ulica);
  488.  
  489.     // similar to i = l-1 for array implementation
  490.     struct ksiazka_telefoniczna *i = l->prev;
  491.     struct ksiazka_telefoniczna *j = l;
  492.  
  493.     // Similar to "for (int j = l; j <= h- 1; j++)"
  494.     for (j = l; j != h; j = j->next)
  495.     {
  496.         if(strcmp(x,j->ulica) == 1 || strcmp(x,j->ulica)==0 )//if (j->ID <= x)
  497.         {
  498.             // Similar to i++ for array
  499.             i = (i == NULL)? l : i->next;
  500.  
  501.             swap(&(i->ID), &(j->ID));
  502.             swap_text((i->imie), (j->imie));
  503.             swap_text((i->nazwisko), (j->nazwisko));
  504.             swap_text((i->ulica), (j->ulica));
  505.             swap_text((i->numer_domu), (j->numer_domu));
  506.             swap_text((i->miasto), (j->miasto));
  507.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  508.             swap_text((i->mail), (j->mail));
  509.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  510.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  511.         }
  512.     }
  513.     i = (i == NULL)? l : i->next; // Similar to i++
  514.     swap(&(i->ID), &(j->ID));
  515.     swap_text((i->imie), (j->imie));
  516.     swap_text((i->nazwisko), (j->nazwisko));
  517.     swap_text((i->ulica), (j->ulica));
  518.     swap_text((i->numer_domu), (j->numer_domu));
  519.     swap_text((i->miasto), (j->miasto));
  520.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  521.     swap_text((i->mail), (j->mail));
  522.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  523.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  524.     return i;
  525. }
  526.  
  527.  
  528. void _quickSort_ulica_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  529. {
  530.     if (h != NULL && l != h && l != h->next)
  531.     {
  532.         struct ksiazka_telefoniczna *p = partition_ulica_rosnaco(l, h);
  533.         _quickSort_ulica_rosnaco(l, p->prev);
  534.         _quickSort_ulica_rosnaco(p->next, h);
  535.     }
  536. }
  537.  
  538.  
  539. void quickSort_ulica_rosnaco(struct ksiazka_telefoniczna *head)
  540. {
  541.     struct ksiazka_telefoniczna *h = lastNode(head);
  542.     _quickSort_ulica_rosnaco(head, h);
  543. }
  544.  
  545. //ULICA MALEJACO
  546.  
  547. struct ksiazka_telefoniczna* partition_ulica_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  548. {
  549.     // set pivot as h element
  550.     char x[40];
  551.     strcpy(x,h->ulica);
  552.  
  553.     // similar to i = l-1 for array implementation
  554.     struct ksiazka_telefoniczna *i = l->prev;
  555.     struct ksiazka_telefoniczna *j = l;
  556.  
  557.     // Similar to "for (int j = l; j <= h- 1; j++)"
  558.     for (j = l; j != h; j = j->next)
  559.     {
  560.         if(strcmp(x,j->ulica) == -1 || strcmp(x,j->ulica)==0 )//if (j->ID <= x)
  561.         {
  562.             // Similar to i++ for array
  563.             i = (i == NULL)? l : i->next;
  564.  
  565.             swap(&(i->ID), &(j->ID));
  566.             swap_text((i->imie), (j->imie));
  567.             swap_text((i->nazwisko), (j->nazwisko));
  568.             swap_text((i->ulica), (j->ulica));
  569.             swap_text((i->numer_domu), (j->numer_domu));
  570.             swap_text((i->miasto), (j->miasto));
  571.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  572.             swap_text((i->mail), (j->mail));
  573.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  574.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  575.         }
  576.     }
  577.     i = (i == NULL)? l : i->next; // Similar to i++
  578.     swap(&(i->ID), &(j->ID));
  579.     swap_text((i->imie), (j->imie));
  580.     swap_text((i->nazwisko), (j->nazwisko));
  581.     swap_text((i->ulica), (j->ulica));
  582.     swap_text((i->numer_domu), (j->numer_domu));
  583.     swap_text((i->miasto), (j->miasto));
  584.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  585.     swap_text((i->mail), (j->mail));
  586.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  587.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  588.     return i;
  589. }
  590.  
  591.  
  592. void _quickSort_ulica_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  593. {
  594.     if (h != NULL && l != h && l != h->next)
  595.     {
  596.         struct ksiazka_telefoniczna *p = partition_ulica_malejaco(l, h);
  597.         _quickSort_ulica_malejaco(l, p->prev);
  598.         _quickSort_ulica_malejaco(p->next, h);
  599.     }
  600. }
  601.  
  602.  
  603. void quickSort_ulica_malejaco(struct ksiazka_telefoniczna *head)
  604. {
  605.     struct ksiazka_telefoniczna *h = lastNode(head);
  606.     _quickSort_ulica_malejaco(head, h);
  607. }
  608.  
  609.  
  610.  
  611. //NUMER DOMU ROSNACO
  612.  
  613. struct ksiazka_telefoniczna* partition_numer_domu_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  614. {
  615.     // set pivot as h element
  616.     char x[40];
  617.     strcpy(x,h->numer_domu);
  618.  
  619.     // similar to i = l-1 for array implementation
  620.     struct ksiazka_telefoniczna *i = l->prev;
  621.     struct ksiazka_telefoniczna *j = l;
  622.  
  623.     // Similar to "for (int j = l; j <= h- 1; j++)"
  624.     for (j = l; j != h; j = j->next)
  625.     {
  626.         if(strcmp(x,j->numer_domu) == 1 || strcmp(x,j->numer_domu)==0 )//if (j->ID <= x)
  627.         {
  628.             // Similar to i++ for array
  629.             i = (i == NULL)? l : i->next;
  630.  
  631.             swap(&(i->ID), &(j->ID));
  632.             swap_text((i->imie), (j->imie));
  633.             swap_text((i->nazwisko), (j->nazwisko));
  634.             swap_text((i->ulica), (j->ulica));
  635.             swap_text((i->numer_domu), (j->numer_domu));
  636.             swap_text((i->miasto), (j->miasto));
  637.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  638.             swap_text((i->mail), (j->mail));
  639.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  640.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  641.         }
  642.     }
  643.     i = (i == NULL)? l : i->next; // Similar to i++
  644.     swap(&(i->ID), &(j->ID));
  645.     swap_text((i->imie), (j->imie));
  646.     swap_text((i->nazwisko), (j->nazwisko));
  647.     swap_text((i->ulica), (j->ulica));
  648.     swap_text((i->numer_domu), (j->numer_domu));
  649.     swap_text((i->miasto), (j->miasto));
  650.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  651.     swap_text((i->mail), (j->mail));
  652.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  653.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  654.     return i;
  655. }
  656.  
  657.  
  658. void _quickSort_numer_domu_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  659. {
  660.     if (h != NULL && l != h && l != h->next)
  661.     {
  662.         struct ksiazka_telefoniczna *p = partition_numer_domu_rosnaco(l, h);
  663.         _quickSort_numer_domu_rosnaco(l, p->prev);
  664.         _quickSort_numer_domu_rosnaco(p->next, h);
  665.     }
  666. }
  667.  
  668.  
  669. void quickSort_numer_domu_rosnaco(struct ksiazka_telefoniczna *head)
  670. {
  671.     struct ksiazka_telefoniczna *h = lastNode(head);
  672.     _quickSort_numer_domu_rosnaco(head, h);
  673. }
  674.  
  675. //NUMER DOMU MALEJACO
  676.  
  677. struct ksiazka_telefoniczna* partition_numer_domu_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  678. {
  679.     // set pivot as h element
  680.     char x[40];
  681.     strcpy(x,h->numer_domu);
  682.  
  683.     // similar to i = l-1 for array implementation
  684.     struct ksiazka_telefoniczna *i = l->prev;
  685.     struct ksiazka_telefoniczna *j = l;
  686.  
  687.     // Similar to "for (int j = l; j <= h- 1; j++)"
  688.     for (j = l; j != h; j = j->next)
  689.     {
  690.         if(strcmp(x,j->numer_domu) == -1 || strcmp(x,j->numer_domu)==0 )//if (j->ID <= x)
  691.         {
  692.             // Similar to i++ for array
  693.             i = (i == NULL)? l : i->next;
  694.  
  695.             swap(&(i->ID), &(j->ID));
  696.             swap_text((i->imie), (j->imie));
  697.             swap_text((i->nazwisko), (j->nazwisko));
  698.             swap_text((i->ulica), (j->ulica));
  699.             swap_text((i->numer_domu), (j->numer_domu));
  700.             swap_text((i->miasto), (j->miasto));
  701.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  702.             swap_text((i->mail), (j->mail));
  703.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  704.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  705.         }
  706.     }
  707.     i = (i == NULL)? l : i->next; // Similar to i++
  708.     swap(&(i->ID), &(j->ID));
  709.     swap_text((i->imie), (j->imie));
  710.     swap_text((i->nazwisko), (j->nazwisko));
  711.     swap_text((i->ulica), (j->ulica));
  712.     swap_text((i->numer_domu), (j->numer_domu));
  713.     swap_text((i->miasto), (j->miasto));
  714.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  715.     swap_text((i->mail), (j->mail));
  716.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  717.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  718.     return i;
  719. }
  720.  
  721.  
  722. void _quickSort_numer_domu_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  723. {
  724.     if (h != NULL && l != h && l != h->next)
  725.     {
  726.         struct ksiazka_telefoniczna *p = partition_numer_domu_malejaco(l, h);
  727.         _quickSort_numer_domu_malejaco(l, p->prev);
  728.         _quickSort_numer_domu_malejaco(p->next, h);
  729.     }
  730. }
  731.  
  732.  
  733. void quickSort_numer_domu_malejaco(struct ksiazka_telefoniczna *head)
  734. {
  735.     struct ksiazka_telefoniczna *h = lastNode(head);
  736.     _quickSort_numer_domu_malejaco(head, h);
  737. }
  738.  
  739.  
  740. //MIASTO ROSNACO
  741.  
  742. struct ksiazka_telefoniczna* partition_miasto_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  743. {
  744.     // set pivot as h element
  745.     char x[40];
  746.     strcpy(x,h->miasto);
  747.  
  748.     // similar to i = l-1 for array implementation
  749.     struct ksiazka_telefoniczna *i = l->prev;
  750.     struct ksiazka_telefoniczna *j = l;
  751.  
  752.     // Similar to "for (int j = l; j <= h- 1; j++)"
  753.     for (j = l; j != h; j = j->next)
  754.     {
  755.         if(strcmp(x,j->miasto) == 1 || strcmp(x,j->miasto)==0 )//if (j->ID <= x)
  756.         {
  757.             // Similar to i++ for array
  758.             i = (i == NULL)? l : i->next;
  759.  
  760.             swap(&(i->ID), &(j->ID));
  761.             swap_text((i->imie), (j->imie));
  762.             swap_text((i->nazwisko), (j->nazwisko));
  763.             swap_text((i->ulica), (j->ulica));
  764.             swap_text((i->numer_domu), (j->numer_domu));
  765.             swap_text((i->miasto), (j->miasto));
  766.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  767.             swap_text((i->mail), (j->mail));
  768.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  769.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  770.         }
  771.     }
  772.     i = (i == NULL)? l : i->next; // Similar to i++
  773.     swap(&(i->ID), &(j->ID));
  774.     swap_text((i->imie), (j->imie));
  775.     swap_text((i->nazwisko), (j->nazwisko));
  776.     swap_text((i->ulica), (j->ulica));
  777.     swap_text((i->numer_domu), (j->numer_domu));
  778.     swap_text((i->miasto), (j->miasto));
  779.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  780.     swap_text((i->mail), (j->mail));
  781.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  782.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  783.     return i;
  784. }
  785.  
  786.  
  787. void _quickSort_miasto_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  788. {
  789.     if (h != NULL && l != h && l != h->next)
  790.     {
  791.         struct ksiazka_telefoniczna *p = partition_miasto_rosnaco(l, h);
  792.         _quickSort_miasto_rosnaco(l, p->prev);
  793.         _quickSort_miasto_rosnaco(p->next, h);
  794.     }
  795. }
  796.  
  797.  
  798. void quickSort_miasto_rosnaco(struct ksiazka_telefoniczna *head)
  799. {
  800.     struct ksiazka_telefoniczna *h = lastNode(head);
  801.     _quickSort_miasto_rosnaco(head, h);
  802. }
  803.  
  804. //MIASTO MALEJACO
  805.  
  806. struct ksiazka_telefoniczna* partition_miasto_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  807. {
  808.     // set pivot as h element
  809.     char x[40];
  810.     strcpy(x,h->miasto);
  811.  
  812.     // similar to i = l-1 for array implementation
  813.     struct ksiazka_telefoniczna *i = l->prev;
  814.     struct ksiazka_telefoniczna *j = l;
  815.  
  816.     // Similar to "for (int j = l; j <= h- 1; j++)"
  817.     for (j = l; j != h; j = j->next)
  818.     {
  819.         if(strcmp(x,j->miasto) == -1 || strcmp(x,j->miasto)==0 )//if (j->ID <= x)
  820.         {
  821.             // Similar to i++ for array
  822.             i = (i == NULL)? l : i->next;
  823.  
  824.             swap(&(i->ID), &(j->ID));
  825.             swap_text((i->imie), (j->imie));
  826.             swap_text((i->nazwisko), (j->nazwisko));
  827.             swap_text((i->ulica), (j->ulica));
  828.             swap_text((i->numer_domu), (j->numer_domu));
  829.             swap_text((i->miasto), (j->miasto));
  830.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  831.             swap_text((i->mail), (j->mail));
  832.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  833.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  834.         }
  835.     }
  836.     i = (i == NULL)? l : i->next; // Similar to i++
  837.     swap(&(i->ID), &(j->ID));
  838.     swap_text((i->imie), (j->imie));
  839.     swap_text((i->nazwisko), (j->nazwisko));
  840.     swap_text((i->ulica), (j->ulica));
  841.     swap_text((i->numer_domu), (j->numer_domu));
  842.     swap_text((i->miasto), (j->miasto));
  843.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  844.     swap_text((i->mail), (j->mail));
  845.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  846.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  847.     return i;
  848. }
  849.  
  850.  
  851. void _quickSort_miasto_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  852. {
  853.     if (h != NULL && l != h && l != h->next)
  854.     {
  855.         struct ksiazka_telefoniczna *p = partition_miasto_malejaco(l, h);
  856.         _quickSort_miasto_malejaco(l, p->prev);
  857.         _quickSort_miasto_malejaco(p->next, h);
  858.     }
  859. }
  860.  
  861.  
  862. void quickSort_miasto_malejaco(struct ksiazka_telefoniczna *head)
  863. {
  864.     struct ksiazka_telefoniczna *h = lastNode(head);
  865.     _quickSort_miasto_malejaco(head, h);
  866. }
  867.  
  868. //KOD POCZTOWY ROSNACO
  869.  
  870. struct ksiazka_telefoniczna* partition_kod_pocztowy_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  871. {
  872.     // set pivot as h element
  873.     char x[40];
  874.     strcpy(x,h->kod_pocztowy);
  875.  
  876.     // similar to i = l-1 for array implementation
  877.     struct ksiazka_telefoniczna *i = l->prev;
  878.     struct ksiazka_telefoniczna *j = l;
  879.  
  880.     // Similar to "for (int j = l; j <= h- 1; j++)"
  881.     for (j = l; j != h; j = j->next)
  882.     {
  883.         if(strcmp(x,j->kod_pocztowy) == 1 || strcmp(x,j->kod_pocztowy)==0 )//if (j->ID <= x)
  884.         {
  885.             // Similar to i++ for array
  886.             i = (i == NULL)? l : i->next;
  887.  
  888.             swap(&(i->ID), &(j->ID));
  889.             swap_text((i->imie), (j->imie));
  890.             swap_text((i->nazwisko), (j->nazwisko));
  891.             swap_text((i->ulica), (j->ulica));
  892.             swap_text((i->numer_domu), (j->numer_domu));
  893.             swap_text((i->miasto), (j->miasto));
  894.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  895.             swap_text((i->mail), (j->mail));
  896.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  897.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  898.         }
  899.     }
  900.     i = (i == NULL)? l : i->next; // Similar to i++
  901.     swap(&(i->ID), &(j->ID));
  902.     swap_text((i->imie), (j->imie));
  903.     swap_text((i->nazwisko), (j->nazwisko));
  904.     swap_text((i->ulica), (j->ulica));
  905.     swap_text((i->numer_domu), (j->numer_domu));
  906.     swap_text((i->miasto), (j->miasto));
  907.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  908.     swap_text((i->mail), (j->mail));
  909.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  910.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  911.     return i;
  912. }
  913.  
  914.  
  915. void _quickSort_kod_pocztowy_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  916. {
  917.     if (h != NULL && l != h && l != h->next)
  918.     {
  919.         struct ksiazka_telefoniczna *p = partition_kod_pocztowy_rosnaco(l, h);
  920.         _quickSort_kod_pocztowy_rosnaco(l, p->prev);
  921.         _quickSort_kod_pocztowy_rosnaco(p->next, h);
  922.     }
  923. }
  924.  
  925.  
  926. void quickSort_kod_pocztowy_rosnaco(struct ksiazka_telefoniczna *head)
  927. {
  928.     struct ksiazka_telefoniczna *h = lastNode(head);
  929.     _quickSort_kod_pocztowy_rosnaco(head, h);
  930. }
  931.  
  932. //MIASTO MALEJACO
  933.  
  934. struct ksiazka_telefoniczna* partition_kod_pocztowy_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  935. {
  936.     // set pivot as h element
  937.     char x[40];
  938.     strcpy(x,h->kod_pocztowy);
  939.  
  940.     // similar to i = l-1 for array implementation
  941.     struct ksiazka_telefoniczna *i = l->prev;
  942.     struct ksiazka_telefoniczna *j = l;
  943.  
  944.     // Similar to "for (int j = l; j <= h- 1; j++)"
  945.     for (j = l; j != h; j = j->next)
  946.     {
  947.         if(strcmp(x,j->kod_pocztowy) == -1 || strcmp(x,j->kod_pocztowy)==0 )//if (j->ID <= x)
  948.         {
  949.             // Similar to i++ for array
  950.             i = (i == NULL)? l : i->next;
  951.  
  952.             swap(&(i->ID), &(j->ID));
  953.             swap_text((i->imie), (j->imie));
  954.             swap_text((i->nazwisko), (j->nazwisko));
  955.             swap_text((i->ulica), (j->ulica));
  956.             swap_text((i->numer_domu), (j->numer_domu));
  957.             swap_text((i->miasto), (j->miasto));
  958.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  959.             swap_text((i->mail), (j->mail));
  960.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  961.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  962.         }
  963.     }
  964.     i = (i == NULL)? l : i->next; // Similar to i++
  965.     swap(&(i->ID), &(j->ID));
  966.     swap_text((i->imie), (j->imie));
  967.     swap_text((i->nazwisko), (j->nazwisko));
  968.     swap_text((i->ulica), (j->ulica));
  969.     swap_text((i->numer_domu), (j->numer_domu));
  970.     swap_text((i->miasto), (j->miasto));
  971.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  972.     swap_text((i->mail), (j->mail));
  973.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  974.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  975.     return i;
  976. }
  977.  
  978.  
  979. void _quickSort_kod_pocztowy_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  980. {
  981.     if (h != NULL && l != h && l != h->next)
  982.     {
  983.         struct ksiazka_telefoniczna *p = partition_kod_pocztowy_malejaco(l, h);
  984.         _quickSort_kod_pocztowy_malejaco(l, p->prev);
  985.         _quickSort_kod_pocztowy_malejaco(p->next, h);
  986.     }
  987. }
  988.  
  989.  
  990. void quickSort_kod_pocztowy_malejaco(struct ksiazka_telefoniczna *head)
  991. {
  992.     struct ksiazka_telefoniczna *h = lastNode(head);
  993.     _quickSort_kod_pocztowy_malejaco(head, h);
  994. }
  995.  
  996.  
  997.  
  998.  
  999.  
  1000. //TELEFON ROSNACO
  1001.  
  1002. struct ksiazka_telefoniczna* partition_telefon_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  1003. {
  1004.     // set pivot as h element
  1005.     int x  = h->numer_telefonu;
  1006.  
  1007.     // similar to i = l-1 for array implementation
  1008.     struct ksiazka_telefoniczna *i = l->prev;
  1009.     struct ksiazka_telefoniczna *j = l;
  1010.  
  1011.     // Similar to "for (int j = l; j <= h- 1; j++)"
  1012.     for (j = l; j != h; j = j->next)
  1013.     {
  1014.         if (j->numer_telefonu <= x)
  1015.         {
  1016.             // Similar to i++ for array
  1017.             i = (i == NULL)? l : i->next;
  1018.  
  1019.             swap(&(i->ID), &(j->ID));
  1020.             swap_text((i->imie), (j->imie));
  1021.             swap_text((i->nazwisko), (j->nazwisko));
  1022.             swap_text((i->ulica), (j->ulica));
  1023.             swap_text((i->numer_domu), (j->numer_domu));
  1024.             swap_text((i->miasto), (j->miasto));
  1025.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1026.             swap_text((i->mail), (j->mail));
  1027.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1028.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1029.         }
  1030.     }
  1031.     i = (i == NULL)? l : i->next; // Similar to i++
  1032.     swap(&(i->ID), &(j->ID));
  1033.     swap_text((i->imie), (j->imie));
  1034.     swap_text((i->nazwisko), (j->nazwisko));
  1035.     swap_text((i->ulica), (j->ulica));
  1036.     swap_text((i->numer_domu), (j->numer_domu));
  1037.     swap_text((i->miasto), (j->miasto));
  1038.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1039.     swap_text((i->mail), (j->mail));
  1040.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1041.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1042.     return i;
  1043. }
  1044.  
  1045.  
  1046. void _quickSort_telefon_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  1047. {
  1048.     if (h != NULL && l != h && l != h->next)
  1049.     {
  1050.         struct ksiazka_telefoniczna *p = partition_telefon_rosnaco(l, h);
  1051.         _quickSort_telefon_rosnaco(l, p->prev);
  1052.         _quickSort_telefon_rosnaco(p->next, h);
  1053.     }
  1054. }
  1055.  
  1056.  
  1057. void quickSort_telefon_rosnaco(struct ksiazka_telefoniczna *head)
  1058. {
  1059.     struct ksiazka_telefoniczna *h = lastNode(head);
  1060.     _quickSort_telefon_rosnaco(head, h);
  1061. }
  1062.  
  1063. //ID MALEJACO
  1064. struct ksiazka_telefoniczna* partition_telefon_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  1065. {
  1066.     // set pivot as h element
  1067.     int x  = h->numer_telefonu;
  1068.  
  1069.     // similar to i = l-1 for array implementation
  1070.     struct ksiazka_telefoniczna *i = l->prev;
  1071.     struct ksiazka_telefoniczna *j = l;
  1072.  
  1073.     // Similar to "for (int j = l; j <= h- 1; j++)"
  1074.     for (j = l; j != h; j = j->next)
  1075.     {
  1076.         if (j->numer_telefonu >= x)
  1077.         {
  1078.             // Similar to i++ for array
  1079.             i = (i == NULL)? l : i->next;
  1080.  
  1081.             swap(&(i->ID), &(j->ID));
  1082.             swap_text((i->imie), (j->imie));
  1083.             swap_text((i->nazwisko), (j->nazwisko));
  1084.             swap_text((i->ulica), (j->ulica));
  1085.             swap_text((i->numer_domu), (j->numer_domu));
  1086.             swap_text((i->miasto), (j->miasto));
  1087.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1088.             swap_text((i->mail), (j->mail));
  1089.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1090.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1091.         }
  1092.     }
  1093.     i = (i == NULL)? l : i->next; // Similar to i++
  1094.     swap(&(i->ID), &(j->ID));
  1095.     swap_text((i->imie), (j->imie));
  1096.     swap_text((i->nazwisko), (j->nazwisko));
  1097.     swap_text((i->ulica), (j->ulica));
  1098.     swap_text((i->numer_domu), (j->numer_domu));
  1099.     swap_text((i->miasto), (j->miasto));
  1100.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1101.     swap_text((i->mail), (j->mail));
  1102.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1103.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1104.     return i;
  1105. }
  1106.  
  1107.  
  1108. void _quickSort_telefon_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  1109. {
  1110.     if (h != NULL && l != h && l != h->next)
  1111.     {
  1112.         struct ksiazka_telefoniczna *p = partition_telefon_malejaco(l, h);
  1113.         _quickSort_telefon_malejaco(l, p->prev);
  1114.         _quickSort_telefon_malejaco(p->next, h);
  1115.     }
  1116. }
  1117.  
  1118.  
  1119. void quickSort_telefon_malejaco(struct ksiazka_telefoniczna *head)
  1120. {
  1121.     struct ksiazka_telefoniczna *h = lastNode(head);
  1122.     _quickSort_telefon_malejaco(head, h);
  1123. }
  1124.  
  1125.  
  1126.  
  1127.  
  1128. //MAIL ROSNACO
  1129.  
  1130. struct ksiazka_telefoniczna* partition_mail_rosnaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  1131. {
  1132.     // set pivot as h element
  1133.     char x[40];
  1134.     strcpy(x,h->mail);
  1135.  
  1136.     // similar to i = l-1 for array implementation
  1137.     struct ksiazka_telefoniczna *i = l->prev;
  1138.     struct ksiazka_telefoniczna *j = l;
  1139.  
  1140.     // Similar to "for (int j = l; j <= h- 1; j++)"
  1141.     for (j = l; j != h; j = j->next)
  1142.     {
  1143.         if(strcmp(x,j->mail) == 1 || strcmp(x,j->mail)==0 )//if (j->ID <= x)
  1144.         {
  1145.             // Similar to i++ for array
  1146.             i = (i == NULL)? l : i->next;
  1147.  
  1148.             swap(&(i->ID), &(j->ID));
  1149.             swap_text((i->imie), (j->imie));
  1150.             swap_text((i->nazwisko), (j->nazwisko));
  1151.             swap_text((i->ulica), (j->ulica));
  1152.             swap_text((i->numer_domu), (j->numer_domu));
  1153.             swap_text((i->miasto), (j->miasto));
  1154.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1155.             swap_text((i->mail), (j->mail));
  1156.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1157.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1158.         }
  1159.     }
  1160.     i = (i == NULL)? l : i->next; // Similar to i++
  1161.     swap(&(i->ID), &(j->ID));
  1162.     swap_text((i->imie), (j->imie));
  1163.     swap_text((i->nazwisko), (j->nazwisko));
  1164.     swap_text((i->ulica), (j->ulica));
  1165.     swap_text((i->numer_domu), (j->numer_domu));
  1166.     swap_text((i->miasto), (j->miasto));
  1167.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1168.     swap_text((i->mail), (j->mail));
  1169.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1170.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1171.     return i;
  1172. }
  1173.  
  1174.  
  1175. void _quickSort_mail_rosnaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  1176. {
  1177.     if (h != NULL && l != h && l != h->next)
  1178.     {
  1179.         struct ksiazka_telefoniczna *p = partition_mail_rosnaco(l, h);
  1180.         _quickSort_mail_rosnaco(l, p->prev);
  1181.         _quickSort_mail_rosnaco(p->next, h);
  1182.     }
  1183. }
  1184.  
  1185.  
  1186. void quickSort_mail_rosnaco(struct ksiazka_telefoniczna *head)
  1187. {
  1188.     struct ksiazka_telefoniczna *h = lastNode(head);
  1189.     _quickSort_mail_rosnaco(head, h);
  1190. }
  1191.  
  1192. //MAIL MALEJACO
  1193.  
  1194. struct ksiazka_telefoniczna* partition_mail_malejaco(struct ksiazka_telefoniczna *l, struct ksiazka_telefoniczna *h)
  1195. {
  1196.     // set pivot as h element
  1197.     char x[40];
  1198.     strcpy(x,h->mail);
  1199.  
  1200.     // similar to i = l-1 for array implementation
  1201.     struct ksiazka_telefoniczna *i = l->prev;
  1202.     struct ksiazka_telefoniczna *j = l;
  1203.  
  1204.     // Similar to "for (int j = l; j <= h- 1; j++)"
  1205.     for (j = l; j != h; j = j->next)
  1206.     {
  1207.         if(strcmp(x,j->mail) == -1 || strcmp(x,j->mail)==0 )//if (j->ID <= x)
  1208.         {
  1209.             // Similar to i++ for array
  1210.             i = (i == NULL)? l : i->next;
  1211.  
  1212.             swap(&(i->ID), &(j->ID));
  1213.             swap_text((i->imie), (j->imie));
  1214.             swap_text((i->nazwisko), (j->nazwisko));
  1215.             swap_text((i->ulica), (j->ulica));
  1216.             swap_text((i->numer_domu), (j->numer_domu));
  1217.             swap_text((i->miasto), (j->miasto));
  1218.             swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1219.             swap_text((i->mail), (j->mail));
  1220.             swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1221.             //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1222.         }
  1223.     }
  1224.     i = (i == NULL)? l : i->next; // Similar to i++
  1225.     swap(&(i->ID), &(j->ID));
  1226.     swap_text((i->imie), (j->imie));
  1227.     swap_text((i->nazwisko), (j->nazwisko));
  1228.     swap_text((i->ulica), (j->ulica));
  1229.     swap_text((i->numer_domu), (j->numer_domu));
  1230.     swap_text((i->miasto), (j->miasto));
  1231.     swap_text((i->kod_pocztowy), (j->kod_pocztowy));
  1232.     swap_text((i->mail), (j->mail));
  1233.     swap(&(i->numer_telefonu), &(j->numer_telefonu));
  1234.     //swap_text((i->wojewodztwo), (j->wojewodztwo));
  1235.     return i;
  1236. }
  1237.  
  1238.  
  1239. void _quickSort_mail_malejaco(struct ksiazka_telefoniczna* l, struct ksiazka_telefoniczna *h)
  1240. {
  1241.     if (h != NULL && l != h && l != h->next)
  1242.     {
  1243.         struct ksiazka_telefoniczna *p = partition_mail_malejaco(l, h);
  1244.         _quickSort_mail_malejaco(l, p->prev);
  1245.         _quickSort_mail_malejaco(p->next, h);
  1246.     }
  1247. }
  1248.  
  1249.  
  1250. void quickSort_mail_malejaco(struct ksiazka_telefoniczna *head)
  1251. {
  1252.     struct ksiazka_telefoniczna *h = lastNode(head);
  1253.     _quickSort_mail_malejaco(head, h);
  1254. }
  1255.  
  1256.  
  1257.  
  1258.  
  1259. ///////////////////DODAWANIE ELEMENTOW LISTY///////////////////
  1260. struct ksiazka_telefoniczna *create_list_ksiazka_telefoniczna(int ID, char imie[],char nazwisko[],char miasto[],char ulica[],char numer_domu[],char kod_pocztowy[],
  1261.                                 int numer_telefonu,char mail[])
  1262. {
  1263.  
  1264.     struct ksiazka_telefoniczna *front = (struct ksiazka_telefoniczna *)malloc(sizeof(struct ksiazka_telefoniczna));
  1265.  
  1266.     if (front != NULL)
  1267.     {
  1268.         front->ID = ID;
  1269.         strcpy(front->imie,imie);
  1270.         strcpy(front->nazwisko,nazwisko);
  1271.         strcpy(front->miasto,miasto);
  1272.         strcpy(front->ulica,ulica);
  1273.         strcpy(front->numer_domu,numer_domu);
  1274.         strcpy(front->kod_pocztowy,kod_pocztowy);
  1275.         //strcpy(front->wojewodztwo,wojewodztwo);
  1276.         front->numer_telefonu = numer_telefonu;
  1277.         strcpy(front->mail,mail);
  1278.         front->prev = NULL;
  1279.         front->next = NULL;
  1280.     }
  1281.     return front;
  1282. }
  1283.  
  1284. struct ksiazka_telefoniczna *insert_front_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front, struct ksiazka_telefoniczna *new_node) {
  1285.  
  1286.     new_node->next = front;
  1287.     front->prev = new_node;
  1288.     return new_node;
  1289. }
  1290.  
  1291.  
  1292. struct ksiazka_telefoniczna *find_spot_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front, int ID) {
  1293.  
  1294.     struct ksiazka_telefoniczna *prev = NULL;
  1295.  
  1296.     while ((NULL != front) && (front->ID < ID))
  1297.     {
  1298.         prev = front;
  1299.         front = front->next;
  1300.     }
  1301.     return prev;
  1302. }
  1303.  
  1304. void insert_after_ksiazka_telefoniczna(struct ksiazka_telefoniczna *node, struct ksiazka_telefoniczna *new_node) {
  1305.  
  1306.     new_node->prev = node;
  1307.     new_node->next = node->next;
  1308.     node->next->prev = new_node;
  1309.     node->next = new_node;
  1310. }
  1311.  
  1312. void insert_back_ksiazka_telefoniczna(struct ksiazka_telefoniczna *back, struct ksiazka_telefoniczna *new_node) {
  1313.  
  1314.     back->next = new_node;
  1315.     new_node->prev = back;
  1316. }
  1317.  
  1318. struct ksiazka_telefoniczna *insert_node_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front,int ID, char imie[],char nazwisko[],char miasto[],char ulica[],char numer_domu[],char kod_pocztowy[],
  1319.                                       int numer_telefonu,char mail[])
  1320. {
  1321.  
  1322.     if (front == NULL)
  1323.         return NULL;
  1324.     struct ksiazka_telefoniczna *new_node = (struct ksiazka_telefoniczna*)malloc(sizeof(struct ksiazka_telefoniczna));
  1325.  
  1326.     if (new_node != NULL)
  1327.     {
  1328.         new_node->ID = ID;
  1329.         strcpy(new_node->imie,imie);
  1330.         strcpy(new_node->nazwisko,nazwisko);
  1331.         strcpy(new_node->miasto,miasto);
  1332.         strcpy(new_node->ulica,ulica);
  1333.         strcpy(new_node->numer_domu,numer_domu);
  1334.         strcpy(new_node->kod_pocztowy,kod_pocztowy);
  1335.         //strcpy(new_node->wojewodztwo,wojewodztwo);
  1336.         new_node->numer_telefonu = numer_telefonu;
  1337.         strcpy(new_node->mail,mail);
  1338.  
  1339.         new_node->prev = new_node->next = NULL;
  1340.         if (front->ID>= ID)
  1341.             return insert_front_ksiazka_telefoniczna(front, new_node);
  1342.         else
  1343.         {
  1344.             struct ksiazka_telefoniczna *node = find_spot_ksiazka_telefoniczna(front, ID);
  1345.             if (NULL != node->next)
  1346.                 insert_after_ksiazka_telefoniczna(node, new_node);
  1347.             else
  1348.                 insert_back_ksiazka_telefoniczna(node, new_node);
  1349.         }
  1350.     }
  1351.     return front;
  1352. }
  1353.  
  1354.  
  1355.  
  1356.  
  1357.  
  1358. ///////////////////USUWANIE ELEMENTOW LISTY///////////////////
  1359.  
  1360. struct ksiazka_telefoniczna *delete_front_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front)
  1361. {
  1362.     struct ksiazka_telefoniczna *next = front->next;
  1363.     if (NULL != next)
  1364.         next->prev = NULL;
  1365.     free(front);
  1366.     return next;
  1367. }
  1368.  
  1369. void delete_within_ksiazka_telefoniczna(struct ksiazka_telefoniczna *node)
  1370. {
  1371.     node->next->prev = node->prev;
  1372.     node->prev->next = node->next;
  1373.     free(node);
  1374. }
  1375.  
  1376. void delete_back_ksiazka_telefoniczna(struct ksiazka_telefoniczna *back)
  1377. {
  1378.     back->prev->next = NULL;
  1379.     free(back);
  1380. }
  1381.  
  1382. struct ksiazka_telefoniczna *znajdz_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front, int ID)
  1383. {
  1384.     while ((NULL != front) && (front->ID != ID))
  1385.         front = front->next;
  1386.     return front;
  1387. }
  1388.  
  1389.  
  1390. void front_back_ksiazka_telefoniczna(struct ksiazka_telefoniczna **front) {
  1391.     for (; NULL != (*front)->prev; *front = (*front)->prev)
  1392.     {
  1393.     }
  1394. }
  1395.  
  1396. struct ksiazka_telefoniczna *delete_node_ksiazka_telefoniczna(struct ksiazka_telefoniczna **front, int ID)
  1397. {
  1398.  
  1399.     if ((*front)->ID == ID && (*front)->next == NULL && (*front)->prev == NULL)
  1400.     {
  1401.         free(*front);
  1402.         *front = NULL;
  1403.         return *front;
  1404.     }
  1405.  
  1406.     if ((*front)->ID == ID && (*front)->next != NULL && (*front)->prev == NULL)
  1407.     {
  1408.         *front = (*front)->next;
  1409.         free((*front)->prev);
  1410.         (*front)->prev = NULL;
  1411.         return *front;
  1412.     }
  1413.  
  1414.     (*front) = znajdz_ksiazka_telefoniczna(*front, ID);
  1415.     struct ksiazka_telefoniczna *node = *front;
  1416.  
  1417.     if ((*front)->ID == ID && (*front)->next != NULL && (*front)->prev != NULL)
  1418.     {
  1419.         (*front)->next->prev = (*front)->prev;
  1420.         (*front)->prev->next = (*front)->next;
  1421.         front_back_ksiazka_telefoniczna(&(*front));
  1422.         free(node);
  1423.         return *front;
  1424.     }
  1425.  
  1426.     if ((*front)->ID == ID && (*front)->next == NULL && (*front)->prev != NULL)
  1427.     {
  1428.         (*front)->prev->next = NULL;
  1429.         front_back_ksiazka_telefoniczna(&(*front));
  1430.         free(node);
  1431.         return *front;
  1432.     }
  1433.     return NULL;
  1434. }
  1435.  
  1436. void zmiana_numeracji(struct ksiazka_telefoniczna *front)
  1437. {
  1438.     int result=1;
  1439.     for(; front != NULL; front = front->next)
  1440.     {
  1441.         front->ID=result;
  1442.         result++;
  1443.     }
  1444. }
  1445.  
  1446. bool sprawdz_numer_ID(struct ksiazka_telefoniczna *front, int numer)
  1447. {
  1448.     for (; NULL != front; front = front->next)
  1449.     {
  1450.         if (front->ID == numer) {
  1451.             return true;
  1452.         }
  1453.     }
  1454.     return false;
  1455. }
  1456.  
  1457.  
  1458. bool sprawdz_lancuch_znakow_ksiazka_telefoniczna(char lancuch[])
  1459. {
  1460.     int i;
  1461.     for(i=0;i<strlen(lancuch);i++)
  1462.         {
  1463.             if(!((lancuch[i]>=65 && lancuch[i]<=90) || (lancuch[i]>=97 && lancuch[i]<=122)||(lancuch[i]==' ')))
  1464.                 return false;
  1465.             if(lancuch[0]>=97 && lancuch[0]<=122)//32
  1466.                 lancuch[0]=lancuch[0]-32;//zamiana pierwszej malej litery na duza
  1467.         }
  1468.     return true;
  1469. }
  1470.  
  1471. int ustal_najwieksze_ID_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front)
  1472. {
  1473.  
  1474.     if(front == NULL)
  1475.     {
  1476.         return -1;
  1477.     }
  1478.     int result = front->ID;
  1479.  
  1480.     for(; front != NULL; front = front->next)
  1481.     {
  1482.         if(result<front->ID)
  1483.         {
  1484.             result=front->ID;
  1485.         }
  1486.     }
  1487.     return result;
  1488.  
  1489. }
  1490.  
  1491. bool wybor_wojewodztwa(char wojewodztwo[])
  1492. {
  1493.     int wybor;
  1494.     puts("1) Wojewodztwo dolnoslaskie");
  1495.     puts("2) Wojewodztwo kujawsko-pomorskie");
  1496.     puts("3) Wojewodztwo lubelskie");
  1497.     puts("4) Wojewodztwo lubuskie");
  1498.     puts("5) Wojewodztwo lodzkie");
  1499.     puts("6) Wojewodztwo malopolskie");
  1500.     puts("7) Wojewodztwo mazowieckie");
  1501.     puts("8) Wojewodztwo opolskie");
  1502.     puts("9) Wojewodztwo podkarpackie");
  1503.     puts("10) Wojewodztwo podlaskie");
  1504.     puts("11) Wojewodztwo pomorskie");
  1505.     puts("12) Wojewodztwo slaskie");
  1506.     puts("13) Wojewodztwo swietokrzyskie");
  1507.     puts("14) Wojewodztwo warminsko-Mazurskie");
  1508.     puts("15) Wojewodztwo wielkopolskie");
  1509.     puts("16) Wojewodztwo zachodniopomorskie");
  1510.  
  1511.     while(scanf("%d", &wybor) != 1) //dopóki nie uda się wczytać
  1512.         {
  1513.         //ew. komunikat błędu
  1514.         int c;
  1515.         while((c = getchar()) != '\n' && c != EOF); //pętla wyciągająca znaki z bufora
  1516.         }
  1517.  
  1518.     switch(wybor)
  1519.     {
  1520.     case 1:
  1521.         sprintf(wojewodztwo,"Dolnoslaskie");
  1522.         break;
  1523.     case 2:
  1524.         sprintf(wojewodztwo,"Kujawsko-Pomorskie");
  1525.         break;
  1526.     case 3:
  1527.         sprintf(wojewodztwo,"Lubelskie");
  1528.         break;
  1529.     case 4:
  1530.         sprintf(wojewodztwo,"Lubuskie");
  1531.         break;
  1532.     case 5:
  1533.         sprintf(wojewodztwo,"Lodzkie");
  1534.         break;
  1535.     case 6:
  1536.         sprintf(wojewodztwo,"Malopolskie");
  1537.         break;
  1538.     case 7:
  1539.         sprintf(wojewodztwo,"Mazowieckie");
  1540.         break;
  1541.     case 8:
  1542.         sprintf(wojewodztwo,"Opolskie");
  1543.         break;
  1544.     case 9:
  1545.         sprintf(wojewodztwo,"Podkarpackie");
  1546.         break;
  1547.     case 10:
  1548.         sprintf(wojewodztwo,"Podlaskie");
  1549.         break;
  1550.     case 11:
  1551.         sprintf(wojewodztwo,"Pomorskie");
  1552.         break;
  1553.     case 12:
  1554.         sprintf(wojewodztwo,"Slaskie");
  1555.         break;
  1556.     case 13:
  1557.         sprintf(wojewodztwo,"Swietokrzyskie");
  1558.         break;
  1559.     case 14:
  1560.         sprintf(wojewodztwo,"Warminsko-Mazurskie");
  1561.         break;
  1562.     case 15:
  1563.         sprintf(wojewodztwo,"Wielkopolskie");
  1564.         break;
  1565.     case 16:
  1566.         sprintf(wojewodztwo,"Zachodniopomorskie");
  1567.         break;
  1568.     default:
  1569.         puts("Bledny wybor");
  1570.         return false;
  1571.         break;
  1572.     }
  1573.  
  1574.     return true;
  1575.  
  1576. }
  1577.  
  1578. void wprowadz_dane_ksiazka_telefoniczna(char imie[],char nazwisko[],char miasto[],char ulica[],char numer_domu[],char kod_pocztowy[],
  1579.                                       int *numer_telefonu,char mail[])
  1580. {
  1581.     char bezpieczny[10];
  1582.  
  1583.  
  1584.  
  1585.  
  1586.     do
  1587.     {
  1588.         printf("Podaj imie: ");
  1589.         scanf("%s", imie);
  1590.     }while(!sprawdz_lancuch_znakow_ksiazka_telefoniczna(imie));
  1591.  
  1592.     do
  1593.     {
  1594.     printf("Podaj nazwisko: ");
  1595.     scanf("%s", nazwisko);
  1596.     }while(!sprawdz_lancuch_znakow_ksiazka_telefoniczna(nazwisko));
  1597.  
  1598.  
  1599.     do
  1600.     {
  1601.         fflush(stdin);
  1602.         printf("Podaj ulice zamieszkania: ");
  1603.         scanf("%[^\n]s", ulica);
  1604.         fflush(stdin);
  1605.     }while(!sprawdz_lancuch_znakow_ksiazka_telefoniczna(ulica));
  1606.  
  1607.  
  1608.     printf("Podaj numer domu: ");
  1609.     scanf("%s", numer_domu);
  1610.  
  1611.     do
  1612.     {
  1613.         fflush(stdin);
  1614.         printf("Podaj miasto zamieszkania: ");
  1615.         scanf("%[^\n]s", miasto);
  1616.         fflush(stdin);
  1617.     }while(!sprawdz_lancuch_znakow_ksiazka_telefoniczna(miasto));
  1618.  
  1619.     do
  1620.     {
  1621.         do
  1622.         {
  1623.         printf("Podaj kod pocztowy: ");
  1624.         scanf("%s", kod_pocztowy);
  1625.         }while(strlen(kod_pocztowy)!=6);
  1626.  
  1627.         if(kod_pocztowy[2] != '-')
  1628.             puts("Zly format kodu pocztowego, wlasciwy to XX-XXX");
  1629.  
  1630.     }while(kod_pocztowy[2] != '-');
  1631.  
  1632.  
  1633.     //printf("Wybierz wojewodztwo: \n\n");
  1634.     //while(!(wybor_wojewodztwa(wojewodztwo)));
  1635.  
  1636.     do
  1637.     {
  1638.         printf("Podaj numer telefonu (9cyfr): ");
  1639.         scanf("%s", bezpieczny);
  1640.         if (atoi(bezpieczny) != 0)
  1641.             *numer_telefonu = atoi(bezpieczny);
  1642.         else
  1643.             continue;
  1644.     } while ((*numer_telefonu < 100000000) || (*numer_telefonu > 999999999));
  1645.  
  1646.  
  1647.  
  1648.     powrot_mail:
  1649.     printf("Podaj adres E-MAIL: ");
  1650.     scanf("%s",mail);
  1651.     int i;
  1652.     int checkmail=0;
  1653.     for(i=0;i<strlen(mail);i++)
  1654.     {
  1655.         if(mail[i]=='@')
  1656.         {
  1657.             checkmail = 1;
  1658.             break;
  1659.         }
  1660.     }
  1661.     if(checkmail == 0)
  1662.     {
  1663.         goto powrot_mail;
  1664.     }
  1665.  
  1666.  
  1667.  
  1668. }
  1669.  
  1670.  
  1671.  
  1672. void save_to_file_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front)
  1673. {
  1674.     FILE *plik;
  1675.     plik = fopen("Ksiazka_telefoniczna.txt","w+");
  1676.  
  1677.     for (; NULL != front; front = front->next)
  1678.     {
  1679.         fprintf(plik,"ID:%d\n",front->ID);
  1680.         fprintf(plik,"Imie:%s\n",front->imie);
  1681.         fprintf(plik,"Nazwisko:%s\n",front->nazwisko);
  1682.         fprintf(plik,"Ulica:%s\n",front->ulica);
  1683.         fprintf(plik,"Numer domu:%s\n",front->numer_domu);
  1684.         fprintf(plik,"Miasto:%s\n",front->miasto);
  1685.         fprintf(plik,"Kod pocztowy:%s\n",front->kod_pocztowy);
  1686.         fprintf(plik,"E-Mail:%s\n",front->mail);
  1687.         fprintf(plik,"Telefon:%d\n\n",front->numer_telefonu);
  1688.  
  1689.     }
  1690.     printf("\n");
  1691.     fclose(plik);
  1692. }
  1693.  
  1694.  
  1695. struct ksiazka_telefoniczna *load_from_file_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front)
  1696. {
  1697.  
  1698.     FILE *plik;
  1699.     plik = fopen("Ksiazka_telefoniczna.txt","r");
  1700.     if(plik == NULL)
  1701.         return front;
  1702.     char a;
  1703.     char ID[20];
  1704.     char nazwisko[20];
  1705.     char imie[20];
  1706.     char ulica[20];
  1707.     char numer_domu[20];
  1708.     char miasto[20];
  1709.     char kod_pocztowy[20];
  1710.     char mail[40];
  1711.     char telefon[20];
  1712.  
  1713.     memset(ID,0,sizeof(ID));
  1714.     memset(nazwisko,0,sizeof(ID));
  1715.     memset(imie,0,sizeof(ID));
  1716.     memset(ulica,0,sizeof(ID));
  1717.     memset(numer_domu,0,sizeof(ID));
  1718.     memset(miasto,0,sizeof(ID));
  1719.     memset(kod_pocztowy,0,sizeof(ID));
  1720.     memset(mail,0,sizeof(ID));
  1721.     memset(telefon,0,sizeof(ID));
  1722.  
  1723.     int line=0;
  1724.  
  1725.     while(!feof(plik))
  1726.     {
  1727.         fscanf(plik,"%c",&a);
  1728.         if(line==0&&a==':')
  1729.             line=1;
  1730.         if(line)
  1731.         {
  1732.             if(ID[0] == 0)
  1733.             {
  1734.                 fgets(ID,20,plik);
  1735.             }
  1736.             else if(imie[0] == 0)
  1737.             {
  1738.                 fgets(imie,20,plik);
  1739.                 int len = strlen(imie);
  1740.                 imie[len-1] = 0;
  1741.             }
  1742.             else if(nazwisko[0] == 0)
  1743.             {
  1744.                 fgets(nazwisko,20,plik);
  1745.                 int len = strlen(nazwisko);
  1746.                 nazwisko[len-1] = 0;
  1747.             }
  1748.             else if(ulica[0] == 0)
  1749.             {
  1750.                 fgets(ulica,20,plik);
  1751.                 int len = strlen(ulica);
  1752.                 ulica[len-1] = 0;
  1753.             }
  1754.             else if(numer_domu[0] == 0)
  1755.             {
  1756.                 fgets(numer_domu,20,plik);
  1757.                 int len = strlen(numer_domu);
  1758.                 numer_domu[len-1] = 0;
  1759.             }
  1760.             else if(miasto[0] == 0)
  1761.             {
  1762.                 fgets(miasto,20,plik);
  1763.                 int len = strlen(miasto);
  1764.                 miasto[len-1] = 0;
  1765.             }
  1766.             else if(kod_pocztowy[0] == 0)
  1767.             {
  1768.                 fgets(kod_pocztowy,20,plik);
  1769.                 int len = strlen(kod_pocztowy);
  1770.                 kod_pocztowy[len-1] = 0;
  1771.             }
  1772.             else if(mail[0] == 0)
  1773.             {
  1774.                 fgets(mail,40,plik);
  1775.                 int len = strlen(mail);
  1776.                 mail[len-1] = 0;
  1777.             }
  1778.             else if(telefon[0] == 0)
  1779.             {
  1780.                 fgets(telefon,20,plik);
  1781.  
  1782.                 if(front == NULL)
  1783.                     front = create_list_ksiazka_telefoniczna(atoi(ID),imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,atoi(telefon),mail);
  1784.                 else
  1785.                     front = insert_node_ksiazka_telefoniczna(front,atoi(ID),imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,atoi(telefon),mail);
  1786.  
  1787.                 memset(ID,0,sizeof(ID));
  1788.                 memset(imie,0,sizeof(imie));
  1789.                 memset(nazwisko,0,sizeof(nazwisko));
  1790.                 memset(ulica,0,sizeof(ulica));
  1791.                 memset(numer_domu,0,sizeof(numer_domu));
  1792.                 memset(miasto,0,sizeof(miasto));
  1793.                 memset(kod_pocztowy,0,sizeof(kod_pocztowy));
  1794.                 memset(mail,0,sizeof(mail));
  1795.                 memset(telefon,0,sizeof(telefon));
  1796.             }
  1797.         }
  1798.         if(a==':'||a=='\n')
  1799.             line=0;
  1800.     }
  1801.     fclose(plik);
  1802.     return front;
  1803. }
  1804.  
  1805.  
  1806.  
  1807. void print_ksiazka_telefoniczna(struct ksiazka_telefoniczna *front)
  1808. {
  1809.  
  1810.     for (; NULL != front; front = front->next)
  1811.     {
  1812.         printf("\nID: %d\n",front->ID);
  1813.         printf("Imie: %s\n",front->imie);
  1814.         printf("Nazwisko: %s\n",front->nazwisko);
  1815.         printf("Ulica: %s\n",front->ulica);
  1816.         printf("Numer domu: %s\n",front->numer_domu);
  1817.         printf("Miasto: %s\n",front->miasto);
  1818.         printf("Kod pocztowy: %s\n",front->kod_pocztowy);
  1819.         printf("E-mail: %s\n",front->mail);
  1820.         printf("Telefon: %d\n\n",front->numer_telefonu);
  1821.  
  1822.  
  1823.     }
  1824.     puts("");
  1825. }
  1826.  
  1827.  
  1828.  
  1829. void edit_ksiazka_telefoniczna(struct ksiazka_telefoniczna *list_pointer,int ID, char imie[],char nazwisko[],char miasto[],char ulica[],char numer_domu[],char kod_pocztowy[],
  1830.                                       int numer_telefonu,char mail[])
  1831. {
  1832.     for (; NULL != list_pointer; list_pointer = list_pointer->next)
  1833.     {
  1834.         if(list_pointer->ID == ID)
  1835.         {
  1836.             strcpy(list_pointer->imie,imie);
  1837.             strcpy(list_pointer->nazwisko,nazwisko);
  1838.             strcpy(list_pointer->miasto,miasto);
  1839.             strcpy(list_pointer->ulica,ulica);
  1840.             strcpy(list_pointer->numer_domu,numer_domu);
  1841.             strcpy(list_pointer->kod_pocztowy,kod_pocztowy);
  1842.             strcpy(list_pointer->mail,mail);
  1843.             list_pointer->numer_telefonu=numer_telefonu;
  1844.             //strcpy(list_pointer->wojewodztwo,wojewodztwo);
  1845.             break;
  1846.         }
  1847.     }
  1848. }
  1849.  
  1850.  
  1851.  
  1852.  
  1853. int main()
  1854. {
  1855.     struct ksiazka_telefoniczna *ksiazka_front = NULL;
  1856.  
  1857.     int ID;
  1858.     int wybor;
  1859.     char imie[40];
  1860.     char nazwisko[40];
  1861.  
  1862.     char ulica[40];
  1863.     char numer_domu[40];
  1864.     char miasto[40];
  1865.     char kod_pocztowy[40];
  1866.  
  1867.     //char wojewodztwo[40];
  1868.     int numer_telefonu;
  1869.     char mail[30];
  1870.     char bezpieczny[10];
  1871.     double start,end;
  1872.  
  1873.  
  1874.  
  1875.     ksiazka_front = load_from_file_ksiazka_telefoniczna(ksiazka_front);
  1876.  
  1877.  
  1878. /*
  1879. 1)Dodawanie nowego kontaktu
  1880. 2)Losowe dodawanie kontaktow
  1881. 2)Usuwanie wybranego kontaktu
  1882. 3)Edycja wybranego kontaktu
  1883. 4)Wyswietlanie wszystkich kontatkow
  1884. 5)Sortowanie
  1885.     -QUICKSORT PO WSZYSTKICH ELEMENTACH ROSNACO/MALEJACO
  1886.     -Wykaz, ze QUICKSORT jest sortowaniem niestabilnym
  1887.     -Wykaz, ze HEAPSORT jest sortowaniem niestabilnym
  1888.     -HEAPSORT PO WSZYSTKICH ELEMENTACH ROSNACO/MALEJACO
  1889.  
  1890.     //dokonaj analizy przesuniec, porownan, oraz czasu wykonywanie algorytmow
  1891. 6) Analiza uzyskanych wynikow.
  1892. 7) Koniec pracy programu
  1893.  
  1894.  
  1895. */
  1896.  
  1897.  
  1898.     do
  1899.     {
  1900.  
  1901.  
  1902.         menu_glowne:
  1903.         do
  1904.         {
  1905.             system("cls");
  1906.             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),14);
  1907.             puts("--------------------");
  1908.             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),14);
  1909.             puts("KSIAZKA TELEFONICZNA");
  1910.             puts("--------------------");
  1911.             SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),15);
  1912.             puts("\n1) Dodawanie nowego kontaktu");
  1913.             puts("2) Usuniecie wybranego kontaktu");
  1914.             puts("3) Edycja wybranego kontaktu");
  1915.             puts("4) Wyswietlanie wszystkich kontatkow");
  1916.             puts("5) Sortowanie");
  1917.             puts("6) Analiza uzyskanych wynikow.");
  1918.             puts("7) Koniec pracy programu");
  1919.             scanf("%s", bezpieczny);
  1920.         }while (atoi(bezpieczny) == 0);
  1921.         wybor = atoi(bezpieczny);
  1922.  
  1923.  
  1924.         switch(wybor)
  1925.         {
  1926.         case 1://Dodawanie nowego kontaktu
  1927.             {
  1928.  
  1929.  
  1930.  
  1931.                 system("cls");
  1932.                 puts("3) Dodawanie nowego kontaktu\n");
  1933.  
  1934.  
  1935.                 wprowadz_dane_ksiazka_telefoniczna(imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,&numer_telefonu,mail);
  1936.  
  1937.                 if(ksiazka_front == NULL)
  1938.                 {
  1939.                     ID = 1;
  1940.                     ksiazka_front = create_list_ksiazka_telefoniczna(ID,imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,numer_telefonu,mail);
  1941.                 }
  1942.  
  1943.                 else
  1944.                 {
  1945.                     ID = ustal_najwieksze_ID_ksiazka_telefoniczna(ksiazka_front)+1;
  1946.                     ksiazka_front = insert_node_ksiazka_telefoniczna(ksiazka_front,ID,imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,numer_telefonu,mail);
  1947.                 }
  1948.  
  1949.  
  1950.  
  1951.                 save_to_file_ksiazka_telefoniczna(ksiazka_front);
  1952.  
  1953.                 puts("DODANO KONTAKT");
  1954.                 system("PAUSE");
  1955.                 break;
  1956.             }
  1957.         case 2://Usuniecie wybranego kontaktu
  1958.             {
  1959.                 system("cls");
  1960.                 puts("3) Usuniecie wybranego kontaktu\n");
  1961.                 if (ksiazka_front == NULL) {
  1962.                     puts("Lista jest pusta");
  1963.                     system("PAUSE");
  1964.                     break;
  1965.                 }
  1966.                 usuwanie_kontakt:
  1967.                 do
  1968.                 {
  1969.                     system("cls");
  1970.                     puts("3) Usuniecie wybranego kontaktu\n");
  1971.                     puts("1) Wyswietl cala liste kontaktow");
  1972.                     puts("2) Wprowadz numer ID kontaktu");
  1973.                     puts("9) Poprzednie menu");
  1974.                     scanf("%s", bezpieczny);
  1975.                 }while(atoi(bezpieczny) == 0);
  1976.                 wybor = atoi(bezpieczny);
  1977.  
  1978.                 switch(wybor)
  1979.                 {
  1980.                 case 1:
  1981.                     {
  1982.                         system("cls");
  1983.                         print_ksiazka_telefoniczna(ksiazka_front);
  1984.                         system("PAUSE");
  1985.                         goto usuwanie_kontakt;
  1986.                     }
  1987.                 case 2:
  1988.                     {
  1989.                         system("cls");
  1990.                         do
  1991.                         {
  1992.                             printf("-------------------------------\nPodaj numer ID kontaktu do usuniecia: ");
  1993.                             scanf("%s",bezpieczny);
  1994.                         }while (atoi(bezpieczny) == 0);
  1995.                         ID = atoi(bezpieczny);
  1996.  
  1997.                         if (!sprawdz_numer_ID(ksiazka_front,ID))
  1998.                         {
  1999.                             puts("Brak kontkatu o takim ID");
  2000.                             system("PAUSE");
  2001.                             goto usuwanie_kontakt;
  2002.                         }
  2003.  
  2004.  
  2005.                         delete_node_ksiazka_telefoniczna(&ksiazka_front,ID);
  2006.                         zmiana_numeracji(ksiazka_front);
  2007.                         save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2008.                         puts("Usunieto kontakt");
  2009.                         system("PAUSE");
  2010.                         break;
  2011.                     }
  2012.                 case 9:
  2013.                     {
  2014.                         goto menu_glowne;
  2015.                     }
  2016.                 default:
  2017.                     {
  2018.                         goto usuwanie_kontakt;
  2019.                     }
  2020.                 }
  2021.             break;
  2022.             }
  2023.         case 3://Edycja wybranego kontaktu
  2024.             {
  2025.                 system("cls");
  2026.                 puts("3) Edycja wybranego kontaktu\n");
  2027.                 if (ksiazka_front == NULL) {
  2028.                     puts("Lista jest pusta");
  2029.                     system("PAUSE");
  2030.                     break;
  2031.                 }
  2032.                 edycja_kontakt:
  2033.                 do
  2034.                 {
  2035.                     system("cls");
  2036.                     puts("3) Edycja wybranego kontaktu\n");
  2037.                     puts("1) Wyswietl cala liste kontaktow");
  2038.                     puts("2) Wprowadz numer ID kontaktu");
  2039.                     puts("9) Poprzednie menu");
  2040.                     scanf("%s", bezpieczny);
  2041.                 }while(atoi(bezpieczny) == 0);
  2042.                 wybor = atoi(bezpieczny);
  2043.  
  2044.                 switch(wybor)
  2045.                 {
  2046.                 case 1:
  2047.                     {
  2048.                         system("cls");
  2049.                         print_ksiazka_telefoniczna(ksiazka_front);
  2050.                         system("PAUSE");
  2051.                         goto edycja_kontakt;
  2052.                     }
  2053.                 case 2:
  2054.                     {
  2055.                         system("cls");
  2056.                         do
  2057.                         {
  2058.                             printf("-------------------------------\nPodaj numer ID kontaktu do edycji: ");
  2059.                             scanf("%s",bezpieczny);
  2060.                         }while (atoi(bezpieczny) == 0);
  2061.                         ID = atoi(bezpieczny);
  2062.  
  2063.                         if (!sprawdz_numer_ID(ksiazka_front,ID))
  2064.                         {
  2065.                             puts("Brak kontkatu o takim ID");
  2066.                             system("PAUSE");
  2067.                             goto edycja_kontakt;
  2068.                         }
  2069.  
  2070.  
  2071.  
  2072.  
  2073.                         wprowadz_dane_ksiazka_telefoniczna(imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,&numer_telefonu,mail);
  2074.                         edit_ksiazka_telefoniczna(ksiazka_front,ID,imie,nazwisko,miasto,ulica,numer_domu,kod_pocztowy,numer_telefonu,mail);
  2075.                         save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2076.                         puts("EDYTOWANO KONTAKT");
  2077.                         system("PAUSE");
  2078.                         break;
  2079.                     }
  2080.                 case 9:
  2081.                     {
  2082.                         goto menu_glowne;
  2083.                     }
  2084.                 default:
  2085.                     {
  2086.                         goto edycja_kontakt;
  2087.                     }
  2088.                 }
  2089.  
  2090.                 break;
  2091.             }
  2092.         case 4://Wyswietlanie wszystkich kontaktow
  2093.             {
  2094.                 system("cls");
  2095.                 print_ksiazka_telefoniczna(ksiazka_front);
  2096.                 system("PAUSE");
  2097.                 break;
  2098.             }
  2099.         case 5:
  2100.             {
  2101.  
  2102.                 system("cls");
  2103.                 puts("5) Sortowanie\n");
  2104.                 if (ksiazka_front == NULL) {
  2105.                     puts("Lista jest pusta");
  2106.                     system("PAUSE");
  2107.                     break;
  2108.                 }
  2109.  
  2110.  
  2111.                 do
  2112.                 {
  2113.                     system("cls");
  2114.                     puts("5) Sortowanie\n");
  2115.                     puts("1) QUICKSORT");
  2116.                     puts("2) HEAPSORT");
  2117.                     puts("3) Wykaz, ze QUICKSORT jest sortowaniem niestabilnym");
  2118.                     puts("4) Wykaz, ze HEAPSORT jest sortowaniem niestabilnym");
  2119.                     puts("9) Poprzednie menu");
  2120.                     scanf("%s", bezpieczny);
  2121.                 }while(atoi(bezpieczny) == 0);
  2122.                 wybor = atoi(bezpieczny);
  2123.  
  2124.                 switch(wybor)
  2125.                 {
  2126.                 case 1:
  2127.                     {
  2128.                         do
  2129.                         {
  2130.                             system("cls");
  2131.                             puts("1) Sortowanie po ID ROSNACO");
  2132.                             puts("2) Sortowanie po ID MALEJACO");
  2133.                             puts("3) Sortowanie po imieniu ROSNACO");
  2134.                             puts("4) Sortowanie po imieniu MALEJACO");
  2135.                             puts("5) Sortowanie po nazwisku ROSNACO");
  2136.                             puts("6) Sortowanie po nazwisku MALEJACO");
  2137.                             puts("7) Sortowanie po ulicy ROSNACO");
  2138.                             puts("8) Sortowanie po ulicy MALEJACO");
  2139.                             puts("9) Sortowanie po numerze domu ROSNACO");
  2140.                             puts("10) Sortowanie po numerze domu MALEJACO");
  2141.                             puts("11) Sortowanie po miescie ROSNACO");
  2142.                             puts("12) Sortowanie po miescie MALEJACO");
  2143.                             puts("13) Sortowanie po kodzie pocztowym ROSNACO");
  2144.                             puts("14) Sortowanie po kodzie pocztowym MALEJACO");
  2145.                             puts("15) Sortowanie po mailu ROSNACO");
  2146.                             puts("16) Sortowanie po mailu MALEJACO");
  2147.                             puts("17) Sortowanie po telefonie ROSNACO");
  2148.                             puts("18) Sortowanie po telefonie MALEJACO");
  2149.                             puts("19) Poprzednie menu");
  2150.                             scanf("%s", bezpieczny);
  2151.                         }while(atoi(bezpieczny) == 0);
  2152.                         wybor = atoi(bezpieczny);
  2153.  
  2154.                         switch(wybor)
  2155.                         {
  2156.                         case 1:
  2157.                             {
  2158.                                 start=obliczSekundy(clock());
  2159.                                 quickSort(ksiazka_front);
  2160.                                 end=obliczSekundy(clock());
  2161.                                 print_ksiazka_telefoniczna(ksiazka_front);
  2162.                                 save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2163.                                 system("PAUSE");
  2164.                                 break;
  2165.                             }
  2166.                         case 2:
  2167.                             {
  2168.                                 start=obliczSekundy(clock());
  2169.                                 quickSort_id_malejaco(ksiazka_front);
  2170.                                 end=obliczSekundy(clock());
  2171.                                 print_ksiazka_telefoniczna(ksiazka_front);
  2172.                                 save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2173.                                 system("PAUSE");
  2174.                                 break;
  2175.                             }
  2176.                         case 3:
  2177.                             {
  2178.                                 start=obliczSekundy(clock());
  2179.                                 quickSort_imie_rosnaco(ksiazka_front);
  2180.                                 end=obliczSekundy(clock());
  2181.                                 print_ksiazka_telefoniczna(ksiazka_front);
  2182.                                 save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2183.                                 system("PAUSE");
  2184.  
  2185.                                 break;
  2186.                             }
  2187.                         case 4:
  2188.                             {
  2189.                                 quickSort_imie_malejaco(ksiazka_front);
  2190.                                 print_ksiazka_telefoniczna(ksiazka_front);
  2191.                                 save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2192.                                 system("PAUSE");
  2193.                                 break;
  2194.                             }
  2195.                         case 5:
  2196.                         {
  2197.                             quickSort_nazwisko_rosnaco(ksiazka_front);
  2198.                             print_ksiazka_telefoniczna(ksiazka_front);
  2199.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2200.                             system("PAUSE");
  2201.                             break;
  2202.                         }
  2203.                         case 6:
  2204.                         {
  2205.                             quickSort_nazwisko_malejaco(ksiazka_front);
  2206.                             print_ksiazka_telefoniczna(ksiazka_front);
  2207.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2208.                             system("PAUSE");
  2209.                             break;
  2210.                         }
  2211.                         case 7:
  2212.                         {
  2213.                             quickSort_ulica_rosnaco(ksiazka_front);
  2214.                             print_ksiazka_telefoniczna(ksiazka_front);
  2215.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2216.                             system("PAUSE");
  2217.                             break;
  2218.                         }
  2219.                         case 8:
  2220.                         {
  2221.                             quickSort_ulica_malejaco(ksiazka_front);
  2222.                             print_ksiazka_telefoniczna(ksiazka_front);
  2223.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2224.                             system("PAUSE");
  2225.                             break;
  2226.                         }
  2227.                         case 9:
  2228.                         {
  2229.                             quickSort_numer_domu_rosnaco(ksiazka_front);
  2230.                             print_ksiazka_telefoniczna(ksiazka_front);
  2231.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2232.                             system("PAUSE");
  2233.                             break;
  2234.                         }
  2235.                         case 10:
  2236.                         {
  2237.                             quickSort_numer_domu_malejaco(ksiazka_front);
  2238.                             print_ksiazka_telefoniczna(ksiazka_front);
  2239.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2240.                             system("PAUSE");
  2241.                             break;
  2242.                         }
  2243.                         case 11:
  2244.                         {
  2245.                             quickSort_miasto_rosnaco(ksiazka_front);
  2246.                             print_ksiazka_telefoniczna(ksiazka_front);
  2247.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2248.                             system("PAUSE");
  2249.                             break;
  2250.                         }
  2251.                         case 12:
  2252.                         {
  2253.                             quickSort_miasto_malejaco(ksiazka_front);
  2254.                             print_ksiazka_telefoniczna(ksiazka_front);
  2255.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2256.                             system("PAUSE");
  2257.                             break;
  2258.                         }
  2259.                         case 13:
  2260.                         {
  2261.                             quickSort_kod_pocztowy_rosnaco(ksiazka_front);
  2262.                             print_ksiazka_telefoniczna(ksiazka_front);
  2263.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2264.                             system("PAUSE");
  2265.                             break;
  2266.                         }
  2267.                         case 14:
  2268.                         {
  2269.                             quickSort_kod_pocztowy_malejaco(ksiazka_front);
  2270.                             print_ksiazka_telefoniczna(ksiazka_front);
  2271.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2272.                             system("PAUSE");
  2273.                             break;
  2274.                         }
  2275.                         case 15:
  2276.                         {
  2277.                             quickSort_mail_rosnaco(ksiazka_front);
  2278.                             print_ksiazka_telefoniczna(ksiazka_front);
  2279.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2280.                             system("PAUSE");
  2281.                             break;
  2282.                         }
  2283.                         case 16:
  2284.                         {
  2285.                             quickSort_mail_malejaco(ksiazka_front);
  2286.                             print_ksiazka_telefoniczna(ksiazka_front);
  2287.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2288.                             system("PAUSE");
  2289.                             break;
  2290.                         }
  2291.                         case 17:
  2292.                         {
  2293.                             quickSort_telefon_rosnaco(ksiazka_front);
  2294.                             print_ksiazka_telefoniczna(ksiazka_front);
  2295.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2296.                             system("PAUSE");
  2297.                             break;
  2298.                         }
  2299.                         case 18:
  2300.                         {
  2301.                             quickSort_telefon_malejaco(ksiazka_front);
  2302.                             print_ksiazka_telefoniczna(ksiazka_front);
  2303.                             save_to_file_ksiazka_telefoniczna(ksiazka_front);
  2304.                             system("PAUSE");
  2305.                             break;
  2306.                         }
  2307.                         case 19:
  2308.                         {
  2309.                             goto menu_glowne;
  2310.  
  2311.                         }
  2312.  
  2313.                         }
  2314.  
  2315.  
  2316.  
  2317.  
  2318.                         break;
  2319.                     }
  2320.  
  2321.                 case 3:
  2322.                     {
  2323.  
  2324.  
  2325.  
  2326.                         quickSort_miasto_rosnaco(ksiazka_front);
  2327.                         print_ksiazka_telefoniczna(ksiazka_front);
  2328.  
  2329.  
  2330.                         struct list *proba_1 = ksiazka_front->next->next;
  2331.                         struct list *proba_2 = ksiazka_front->next->next->next;
  2332.                         quickSort_miasto_rosnaco(ksiazka_front);
  2333.                         if(proba_1 != proba_2)
  2334.                         {
  2335.                             puts("WYSTAPILA ZAMIANA MIRJSCAMI POMIEDZY ID 3 I ID 4");
  2336.                         }
  2337.  
  2338.                         system("PAUSE");
  2339.  
  2340.  
  2341.  
  2342.                         break;
  2343.                     }
  2344.  
  2345.                 }
  2346.  
  2347.  
  2348.  
  2349.  
  2350.  
  2351.  
  2352.  
  2353.  
  2354.  
  2355.  
  2356.  
  2357.  
  2358.  
  2359.  
  2360.  
  2361.  
  2362.  
  2363.  
  2364.  
  2365.  
  2366.  
  2367.  
  2368.                 break;
  2369.  
  2370.  
  2371.  
  2372.  
  2373.  
  2374.             }
  2375.         case 6://analiza
  2376.             {
  2377.                 printf("Czas podczas wykonywania quicksort wynosi %lf\n", end-start);
  2378.                 printf("Srednia ilosc porownan %d\n", staty.porownania);
  2379.                 printf("Srednia ilosc przesuniec %d\n", staty.przesuniecia);
  2380.                 system("PAUSE");
  2381.                 break;
  2382.             }
  2383.         case 7://Koniec pracy programu
  2384.             {
  2385.                 return 0;
  2386.             }
  2387.         default:
  2388.             {
  2389.                 goto menu_glowne;
  2390.             }
  2391.         }
  2392.  
  2393.  
  2394.  
  2395.  
  2396.  
  2397.  
  2398.  
  2399.  
  2400.  
  2401.  
  2402.  
  2403.  
  2404.  
  2405.  
  2406.  
  2407.  
  2408.  
  2409.  
  2410.  
  2411.  
  2412.  
  2413.  
  2414.  
  2415.  
  2416.  
  2417.  
  2418.  
  2419.  
  2420.  
  2421.  
  2422.  
  2423.  
  2424.  
  2425.  
  2426.  
  2427.  
  2428.  
  2429.  
  2430.  
  2431.  
  2432.  
  2433.  
  2434.  
  2435.  
  2436.  
  2437.  
  2438.  
  2439.     }while(1);
  2440.  
  2441.  
  2442.  
  2443.  
  2444.  
  2445.  
  2446.  
  2447.  
  2448.  
  2449.  
  2450.  
  2451.  
  2452. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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!