C programs

Thursday, January 12, 2006

 

Spregnute liste

  1.  
  2. /************************************************************************************
  3. *
  4. *  Napisati C program koji demonstrira realizaciju osnovnih operacija sa dinamickom strukturom podataka
  5. *  oblika jednostruko spregnute liste. Element liste se sastoji od dva polja: podatak koji predstavlja ceo broj
  6. *  i pokazivac na sledeci element liste.
  7. *  Operacije koje treba realizovati sa jednostruko spregnutom listom su:
  8. *  - unos novog broja, po izboru korisnika (na pocetak ili kraj liste) (NAPOMENA: Zadovoljiti uslov da se u listi
  9. *       ne moze nalaziti vise od 5 istih brojeva)
  10. *  - modifikacija (umesto jednog broja treba upisati drugi broj)
  11. *  - trazenje broja u listi
  12. *  - brisanje broja iz liste (ako ima vise istih, izbrisati ih sve)
  13. *  DODATNO: Napraviti tabelarni prikaz pojavljivanja brojeva u listi
  14. *
  15. *************************************************************************************/
  16. #include <stdio.h>
  17. #define MAX 5
  18.  
  19. /**************************************************
  20. *
  21. *  struktura podataka za listu
  22. *  broj sadrzi podatak
  23. *  sledeci je pokazivac na sledeci elenetan liste
  24. *
  25. **************************************************/
  26. typedef struct cvor {
  27.     int broj;
  28.     struct cvor *sledeci;
  29.     } Tcvor;
  30.  
  31. /*************************
  32. *
  33. *  Pokazivac na cvor
  34. *
  35. **************************/
  36. typedef Tcvor *Pcvor;
  37.  
  38. /**************************************************
  39. *
  40. *  Prototipovi funkcija (detalji su u samim funkcijama)
  41. *
  42. **************************************************/
  43. void ini (Pcvor *);
  44. void unosKr (Pcvor *);
  45. void unosPoc (Pcvor *);
  46. void unosPrvi (Pcvor *);
  47. void ispis (Pcvor);
  48. void mod (Pcvor);
  49. void trazi (Pcvor);
  50. void brisi (Pcvor *);
  51. void osobodiMem (Pcvor *);
  52. int opcije(void);
  53. int prebroj(Pcvor, int);
  54. void brPon(Pcvor);
  55. /*char getch();*/
  56.  
  57.  
  58. main () {
  59.     /********************************************************************************
  60.     *
  61.     *  Definicija promenljivih
  62.     *  glava je pokazivac na prvi element liste (kad je lista prazna glava pokazuje na NULL
  63.     *  izbor je promenljiva koja sluzi za biranje opcija iz menija
  64.     *
  65.     ********************************************************************************/
  66.     Pcvor glava;
  67.     int izbor;
  68.    
  69.     /**********************************************************
  70.     *
  71.     *  Uvodna konverzacija
  72.     *
  73.     **********************************************************/
  74.     printf("\nProgram za prezentaciju osnovnih operacija jednostruko spregnute liste!\n\n");
  75.  
  76.     /***************************************
  77.     *
  78.     *  Inicijalizacija liste
  79.     *
  80.     ***************************************/
  81.     ini (&glava);
  82.    
  83.     /*******************************************************************
  84.     *
  85.     *  Prikazivanje menija na ekranu i izvrsavanje operacija koje korisnik zahteva
  86.     *  sve dok korisnik ne izabere kraj
  87.     *
  88.     ********************************************************************/
  89.         do {
  90.             izbor = opcije();
  91.             switch (izbor) {
  92.                 case 1: unosPoc(&glava);
  93.                             break;
  94.                 case 2: unosKr(&glava);
  95.                             break;
  96.                 case 3: mod(glava);
  97.                             break;
  98.                 case 4: trazi(glava);
  99.                             break;
  100.                 case 5: brisi(&glava);
  101.                             break;
  102.                 case 6: ispis(glava);
  103.                             break;
  104.                 case 7: brPon(glava);
  105.                             break;
  106.                 case 8: ;
  107.            
  108.             }
  109.            
  110.         } while (izbor!=8);
  111.        
  112.         /***************************************
  113.         *
  114.         *  Oslobadjanje zauzete memorije
  115.         *
  116.         ****************************************/
  117.         osobodiMem(&glava);
  118.  
  119. /************************************
  120. *
  121. *  Kraj programa
  122. *
  123. ************************************/
  124. printf("\n\n***KRAJ PROGRAMA***\n\n\n");
  125. return 0;
  126.  
  127. }
  128.  
  129.  
  130.  
  131.  
  132.  
  133. /******************************************************************
  134. *
  135. *  Funkcija: ini
  136. *  Svrha: postavlja vodeci pokazivac (glava) na NULL, odnosno inicijalizuje listu
  137. *
  138. ******************************************************************/
  139. void ini (Pcvor *glava) {
  140.     *glava = NULL; /*postavljanje glave liste da pokazuje na NULL, odnosno na nista*/
  141. }
  142.  
  143.  
  144.  
  145.  
  146.  
  147. /******************************************************************
  148. *
  149. *  Funkcija: unosKr
  150. *  Svrha:  unos novog clana liste i smestanje na kraj
  151. *
  152. ******************************************************************/
  153. void unosKr (Pcvor *glava) {
  154.     /***************************************************************************
  155.     *
  156.     *  Definicija lokalnih promenljivih
  157.     *  tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
  158.     *  novi je element koji je unosi
  159.     *  k je broj koji se unosi
  160.     *
  161.     ****************************************************************************/
  162.     int k;
  163.     Pcvor tek, pret, novi;
  164.        
  165.         printf("\nUnos elementa na kraj liste!\n");
  166.    
  167.         /*ako se utvrdi da je lista prazna poziva se funkcija za unos prvog clana*/
  168.         if (*glava==NULL) unosPrvi (glava); 
  169.             /*a ako lista nije prazna clan se dodaje na kraj*/
  170.             else {
  171.                 /*prolazak kroz listu i dolazak do poslednjeg unesenog elementa*/
  172.                 tek = *glava;
  173.                 while (tek != NULL) {
  174.                     pret = tek;
  175.                     tek = tek->sledeci;
  176.                 }
  177.                
  178.                 /*********************************************************************
  179.                 *
  180.                 *  Zauzimanje dinamicke memorije za novi clan liste, ucitavanje
  181.                 *  broja sa tastature, postaljanje pokazivaca na sledeci element
  182.                 *  na NULL i pokazivaca prethodnog elementa na upravo uneseni element
  183.                 *
  184.                 ********************************************************************/
  185.                 printf("Unesite sledeci element (smesta se na kraj): ");
  186.                 scanf("%d", &k);
  187.                 if (prebroj(*glava, k)<MAX) {
  188.                         novi = (Tcvor *)malloc(sizeof(Tcvor));
  189.                         novi->broj = k;
  190.                         novi->sledeci = NULL;
  191.                         pret->sledeci = novi;      
  192.                 }
  193.                 else printf("\n\tBroj se pojavljivao maximalan broj puta! Nije dozvoljen unos ovog broja!");
  194.     }
  195. }
  196.  
  197.  
  198.  
  199.  
  200.  
  201. /******************************************************************
  202. *
  203. *  Funkcija: unosPoc
  204. *  Svrha:  unos novog clana liste i smestanje na pocetak
  205. *
  206. ******************************************************************/
  207. void unosPoc(Pcvor *glava) {
  208.     /**************************************************************
  209.     *
  210.     *  Definisanje lokalnih promenljivih
  211.     *  novi je element koji se dodaje u listu
  212.     *  k je novi broj koji se unosi
  213.     *
  214.     **************************************************************/
  215.     int k;
  216.     Pcvor novi;
  217.    
  218.     printf("\nUnos elementa na pocetak liste!\n");
  219.    
  220.     /*ako se utvrdi da je lista prazna poziva se funkcija za unos prvog clana*/
  221.     if (*glava==NULL) unosPrvi(glava); 
  222.         /*a ako lista nije prazna, elemet se unosi na pocetak liste*/
  223.         else {
  224.         /********************************************************
  225.         *
  226.         *  Zauzimanje dinamicke memorije za novi element liste, ucitavanje novog
  227.         *  elementa sa tastature, postavljanje glave da pokazuje na taj novi element,
  228.         *  i postavljanje pokazivaca novog elementa da pokazuje da dosadasnji
  229.         *  prvi element, koji je sad drugi
  230.         *
  231.         ********************************************************/
  232.         printf("Unesite sledeci elementa liste (smesta se na pocetak): ");
  233.         scanf("%d", &k);
  234.         if (prebroj(*glava, k)<MAX) {
  235.                 novi = (Tcvor *)malloc(sizeof(Tcvor));
  236.                 novi->broj = k;
  237.                 novi->sledeci = *glava;
  238.                 *glava = novi;
  239.                 }
  240.                 else printf("\n\tBroj se pojavljivao maximalan broj puta! Nije dozvoljen unos ovog broja!");
  241.     }
  242.    
  243. }
  244.  
  245.  
  246.  
  247.  
  248.  
  249.  
  250. /********************************************************
  251. *
  252. *  Funkcija: unosPrvi
  253. *  Svrha:  Sluzi za unos elementa ukoliko je lista prazna
  254. *     nema je smisla pozivati bez prethode prove da li glava pokazuje
  255. *         na NULL
  256. *
  257. *********************************************************/
  258. void unosPrvi (Pcvor *glava) {
  259.         /**************************************************************
  260.         *
  261.         *  Definisanje lokalnih promenljivih
  262.         *  novi je element koji se dodaje u listu
  263.         *
  264.         **************************************************************/
  265.         Pcvor novi;
  266.        
  267.         /*************************************************************
  268.         *
  269.         *  Zauzimanje dinamicke memorije za prvi element u listi, unos sa tastature,
  270.         *  postavljanje njegovog pokazivaca na NULL i postavljanje glave da pokazuje
  271.         *  ne njega
  272.         *
  273.         *************************************************************/
  274.         novi = (Tcvor *)malloc(sizeof(Tcvor));
  275.         printf("Unesite prvi element liste: ");
  276.         scanf("%d", &novi->broj);
  277.         novi->sledeci = NULL;
  278.         *glava = novi;
  279.  
  280. }
  281.  
  282.  
  283.  
  284.  
  285.  
  286. /*********************************************************
  287. *
  288. *  Funckija: ispis
  289. *  Svrha:  ispisivanje na ekranu svih clanova liste
  290. *
  291. *********************************************************/
  292. void ispis (Pcvor glava) {
  293.     /***************************************************************************
  294.     *
  295.     *  Definicija lokalnih promenljivih
  296.     *  tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
  297.     *
  298.     ****************************************************************************/
  299.     Pcvor tek, pret;
  300.    
  301.     /*lista je prazna ako glava pokazuje na NULL*/
  302.     if (glava==NULL) printf("\nLista je prazna\n");
  303.     /*a ako nije prazna ispisujemo listu*/
  304.     else {
  305.    
  306.         /*************************************************************
  307.         *
  308.         *  tek se krece kroz listu dok ne naidje na pokazivac sa vrednoscu NULL, a
  309.         *  pret ga prati i ispisuje se broj na koji pokazuje prethodni.
  310.         *  Ispis se zavrsava kad tek dodje do poslednjeg elementa. Tada pret pokazuje
  311.         *  na poslednji element, a tek ima vrednost pokazivaca poslednjeg elementa,
  312.         *  odnosno NULL.
  313.         *
  314.         *************************************************************/
  315.         printf("\nIspis liste:\n\n");
  316.         tek = glava;
  317.         while (tek !=NULL) {
  318.             pret  = tek;
  319.             printf("\t%d", pret->broj);
  320.             tek = tek->sledeci;
  321.             }
  322.     }
  323.     printf("\n");
  324. }
  325.  
  326.  
  327.  
  328.  
  329.  
  330. /******************************************************************
  331. *
  332. *  Funkcija: mod
  333. *  Svrha: menja zadati broj za drugim zadatim brojem na svakom mestu gde se pojavljuje
  334. *
  335. ******************************************************************/
  336. void mod (Pcvor glava) {
  337.     /*************************************************************
  338.     *
  339.     *  Definicjia lokalnih promenljivih
  340.     *  k je broj koji se modifikuje
  341.     *  n je broj koji zamenjuje k
  342.     *  tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
  343.     *  br je broj modifikovanih elemenata
  344.     *
  345.     *************************************************************/
  346.     int k, n, br=0;
  347.     Pcvor tek, pret;
  348.    
  349.     printf("\nModifikacija broja iz liste!\n\n");
  350.    
  351.     /*ako glava pokazuje na NULL lista je prazna, pa nema sta da se modifikuje*/
  352.     if (glava==NULL) {
  353.         printf("\n\tLista je prazna. Nema elemenata za modifikovanje!\n");
  354.     }
  355.     /*a ako nije prazna, unosi se broj koji treba modifikovati, i broj u koji se modifikuje taj broj*/
  356.     else {
  357.             printf("\tUnesite broj koji hocete da promenite\n\t (promenice se na svim lokacijama gde se pojavljuje): ");
  358.             scanf("%d", &k);
  359.             printf("\tUnesite broj sa kojim hocete da zamenite broj %d : ", k);
  360.             scanf("%d", &n);
  361.            
  362.             if ((prebroj(glava, k) + prebroj(glava, n))<=MAX) {
  363.            
  364.                     /*************************************************************
  365.                     *
  366.                     *  tek prolazi kroz celu listu dok ne naidje na element sa pokazivacom NULL
  367.                     *  (poslednji element), a pret ga prati i proverava da li je element jednak
  368.                     *  broj koji treba modifikovati, i ako jeste menja mu vrednost.
  369.                     *  Petlja se prekida kad tek dobije vrednost NULL. Tada pret pokazuje na posednji
  370.                     *  element, a tek ima vrednost pokazivaca poslednjeg elementa, odnosno NULL.
  371.                     *
  372.                     *************************************************************/
  373.                     tek = glava;
  374.                     while (tek != NULL) {
  375.                             pret = tek;
  376.                             if (pret->broj==k) {
  377.                                 pret->broj = n;
  378.                                 br++;
  379.                                 }
  380.                             tek = tek->sledeci;
  381.                         }
  382.                    
  383.                     if (br==0) printf("\n\tNi jedan element nije modifikovan!\n");
  384.                         else printf("Broj elemenata koji su modifikovani je: %d!\n", br);
  385.             }
  386.             else printf("\n\n\tUkoliko se izvrsi modifikacija, broj %d ce se\n\tpojavljivati u listi vise puta nego sto je to dozvoljeno!\n", n);
  387.                
  388.         }
  389. }
  390.  
  391.  
  392.  
  393.  
  394.  
  395.  
  396. /*******************************************************
  397. *
  398. *  Funkcija: trazi
  399. *  Svrha: proverava da li se odredjeni broj nalazi u listi
  400. *
  401. *******************************************************/
  402. void trazi (Pcvor glava) {
  403.     /********************************************************************************
  404.     *
  405.     *  Definisanje lokalnih promenljivih i enumeracije
  406.     *  k je broj koji se trazi
  407.     *  n pamti da li je broj pronadjen broj u listi
  408.     *  tek je tekuci element liste, a pret je prethodni (prethodni uvek kasni za 1 u odnosu na tekuci)
  409.     *  br je broj pojavljivanja trazenog elementa u listi
  410.     *
  411.     ********************************************************************************/
  412.     int k, br=0;
  413.     Pcvor tek, pret;
  414.    
  415.    
  416.     printf("\nPretraga liste!\n\n");
  417.    
  418.     /*ako glava pokazuje na NULL lista je prazna i nema sta da se pretrazuje*/
  419.     if (glava==NULL) {
  420.         printf("\n\tLista je prazna. Nema elemenata za pretragu!\n");
  421.         }
  422.         /*a ako nije prazna unosi se broj koji se trazi*/
  423.         else {
  424.    
  425.                 printf("\tKoji broj zelite da nadjete u listi? ");
  426.                 scanf("%d", &k);
  427.                 tek = glava;
  428.                
  429.                 /**********************************************************
  430.                 *
  431.                 *  tek i pret prolaze kroz listu (pret kasni za tek) i proverava se za svaki
  432.                 *  element liste da li je jedank trazenom broju. Ako jeste brojac se uvecava
  433.                 *  za jedan.
  434.                 *
  435.                 **********************************************************/
  436.                 while (tek != NULL) {
  437.                     pret = tek;
  438.                     if (pret->broj==k) {
  439.                             br++;
  440.                         }
  441.                         tek = tek->sledeci;
  442.                 }
  443.                
  444.                 /***********************************************************
  445.                 *
  446.                 *  Ako je brojac jedank nuli, ne postoji u listi element koji se trazi, a ako nije
  447.                 *  ispisuje se koliko puta se taj element pojavljuje
  448.                 *
  449.                 ***********************************************************/
  450.                 if (br==0) printf("\n\tTrazeni broj ne postoji u listi!\n");
  451.                     else printf("\n\tBroj puta koliko se broj %d pojavljuje u listi je: %d!\n", k, br);
  452.  
  453.                    
  454.     }
  455. }
  456.  
  457.  
  458.  
  459.  
  460.  
  461. /**********************************************************
  462. *
  463. *  Funkcija: brisi
  464. *  Svrha: brise broj koji je korisnik zadao iz liste gde god se pojavi
  465. *
  466. **********************************************************/
  467. void brisi (Pcvor *glava) {
  468.     /*****************************************************************
  469.     *
  470.     *  Definisanje lokalnih promenljivih
  471.     *  enumeracija sluzi za lakse pamcenje da li jos ima elementa u listi koje treba brisati
  472.     *  k je broj koji treba obrisati
  473.     *  n pamti da li ima jos elemenata koje treba brisati
  474.     *  br je broj obrisanih
  475.     *  tek i pret su pokazivaci na cvorove koji prolaze kroz listu
  476.     *
  477.     ******************************************************************/
  478.     enum {NEMA, IMA};
  479.     int k, n=IMA, br=0;
  480.     Pcvor tek, pret;
  481.    
  482.     printf("\nBrisanje elementa iz liste!\n\n");
  483.    
  484.     /*ako je lista prazna, nema sta da se brise*/
  485.     if (*glava==NULL) {
  486.         printf("\n\tLista je prazna. Nema elemenata za brisanje!\n");
  487.         }
  488.        
  489.         /*a ako nije, unosi se broj koji treba obrisati*/
  490.         else {
  491.    
  492.             printf("\n\tKoji broj zelite da obrisete (bice obrisan sa svih lokacija)? ");
  493.             scanf("%d", &k);
  494.            
  495.             /*ova petlja se ponavlja dok ima elemenata za brisanje*/
  496.             while (n==IMA) {
  497.                     /*trazi element koji odgovara uslovima za brisanje*/
  498.                     tek = *glava;
  499.                     pret = *glava;
  500.                     while ((tek!=NULL) && (tek->broj !=k)) {
  501.                         pret = tek;
  502.                         tek = tek->sledeci; 
  503.                     }
  504.                    
  505.                     /*ako tek pokazuje na NULL znaci da je pretraga dosla do kraja i da nije
  506.                     pronadjen ni jedan element za brisanje, pa se n postavlja na vresnost nema*/
  507.                     if (tek==NULL) {
  508.                         n = NEMA;
  509.                         }
  510.                         /*u suprotnom ako je element za brisanje prvi element liste, glava se postavlja da pokazuje na drugi
  511.                         element, a pokazivacu prvog se dodeljuje vrenost NULL*/
  512.                         else {
  513.                             if (tek==*glava) {
  514.                                 *glava = tek->sledeci;
  515.                                 tek->sledeci = NULL;
  516.                            
  517.                             }
  518.                             /*ako nije brvi element u pitanju, pokazivacu njegovog prethodnika se daje vrednost njegovog pokazivaca
  519.                             (njegov sledbenik), a njegov pokazivac se postavlja na NULL*/
  520.                             else  {
  521.                                 pret->sledeci = tek->sledeci;
  522.                                 tek->sledeci = NULL;
  523.                             }
  524.                             /*i na kraju i fizicki oslobadjamo memoriju koju je zauzimao taj element*/
  525.                             free(tek);
  526.                             /*povecavamo broj obrisanih za jedan*/
  527.                             br++;
  528.                         }
  529.                        
  530.             }
  531.         if (br==0) printf("\n\tNi jedan element nije obrisan\n");
  532.             else printf("\n\tBroj lokacija sa kojih je broj %d izbrisan je: %d!\n", k, br);
  533.         }
  534. }
  535.  
  536.  
  537.  
  538.  
  539.  
  540. /*********************************************************
  541. *
  542. *  Funkcija osobodiMem
  543. *  Svrha: brise celu listu iz dinamicke memorije
  544. *
  545. *********************************************************/
  546. void osobodiMem (Pcvor *glava) {
  547.     /**************************************************
  548.     *
  549.     *  Definisanje lokalnih promenljivih
  550.     *  tek je cvor koji se trenutno brise (prvi clan liste)
  551.     *
  552.     ***************************************************/
  553.     Pcvor tek;
  554.    
  555.         /****************************************************************
  556.         *
  557.         *  Oslobadjanje memorije se vrsi tako sto se brise prvi element iz liste, drugi se
  558.         *  postavlja da bude prvi i to se ponavlja dok svi elementi ne budu izbrisani.
  559.         *  Posto glava uzima vrednost pokazivaca prvog elementa, imace vrednost NULL kada
  560.         *  se poslednji element obrise. Samim tim i znamo da je lista prazna, jer glava ima
  561.         *  vrednost NULL.
  562.         *
  563.         *****************************************************************/
  564.         while (*glava!=NULL) {
  565.             tek = *glava;
  566.             *glava = tek->sledeci;
  567.             free(*glava);   
  568.         }
  569.    
  570. }
  571.  
  572.  
  573.  
  574.  
  575.  
  576. /**********************************************************
  577. *
  578. *  Funkcija: opcije
  579. *  Svrha:  prikazijavnje osnovnog menije za izbor
  580. *
  581. **********************************************************/
  582. int opcije () {
  583.     /***********************************************************************************
  584.     *
  585.     *  Definicija lokalnih promenljivih
  586.     *  izbor je promenljiva koji pamti sta je izabrano iz menija i to je vrednost koju f-ja vraca
  587.     *
  588.     ************************************************************************************/
  589.     int izbor=0;
  590.  
  591.     /*ispisivanje menija i ucitavanje vredosti koju je korisnik uneo sa tastature*/
  592.     printf("\n\t1) Dodaj na pocetak\n\t2) Dodaj na kraj\n\t3) Modifikuj\n\t4) Pretrazi\n\t5) Obrisi\n\t6) Ispisi\n\t7) Tabelarni prikaz\n\t8) Kraj\n");
  593.     printf("\n\tIzaberite opciju: ");
  594.     scanf("%d", &izbor);
  595.  
  596.     while ((izbor>8) || (izbor<1)) {
  597.         printf("\t\tNe postoji ta opcija!");
  598.         printf("\n\t1) Dodaj na pocetak\n\t;2) Dodaj na kraj\n\t3) Modifikuj\n\t4) Pretrazi\n\t5) Obrisi\n\t6) Ispisi\n\t7) Tabelarni prikaz\n\t8) Kraj\n");
  599.         printf("\n\tIzaberite opciju: ");
  600.         scanf("%d", &izbor);
  601.  
  602.     }
  603.    
  604.     /*vracanje ucitane vrednosti*/
  605.     return izbor;
  606.    
  607. }
  608.  
  609.  
  610.  
  611.  
  612.  
  613.  
  614. /*********************************************************************
  615. *
  616. *  Funkcija: prebroj
  617. *  Svrha: broji koliko puta se u listi pojavljuje neki clan
  618. *
  619. *********************************************************************/
  620. int prebroj (Pcvor glava, int broj) {
  621.     /*******************************************************
  622.     *
  623.     *  Definisanje lokalnih promenljivih
  624.     *  br pamti broj ponavljanja nekog broja u listi
  625.     *  tek i pret sluze za prolazak kroz listu
  626.     *
  627.     *******************************************************/
  628.     int br=0;
  629.     Pcvor tek, pret;
  630.    
  631.     tek = glava;
  632.     while (tek!=NULL) {
  633.         pret = tek;
  634.         if (pret->broj==broj) br++;
  635.         tek = tek->sledeci;
  636.    
  637.     }
  638.  
  639.     return br;
  640.    
  641. }
  642.  
  643.  
  644.  
  645.  
  646.  
  647.  
  648. /********************************************************************
  649. *
  650. *  Funkcija: brPov
  651. *  Svrha: prikazuje tabelarni prikaz koliko se puta koji broj pojavljivao u listi
  652. *
  653. ********************************************************************/
  654. void brPon(Pcvor glava) {
  655.    
  656.     /*int k;
  657.     Pcvor tek, pret;
  658.    
  659.     printf("\n\tTablearni prikaz broja pojavljivanja elemenata u listi!\n");
  660.    
  661.     tek = glava;
  662.     while (tek!=NULL) {
  663.         pret = tek;
  664.         k = prebroj(glava, pret->broj);
  665.         printf("%d se pojavljivao %d", pret->broj, k);
  666.         if (k==1) printf(" put!\n\n");
  667.             else printf(" puta!\n\n");
  668.         tek = tek->sledeci;
  669.    
  670.     }
  671.     */
  672.    
  673.     /*****************************************************************
  674.     *
  675.     *  Alternativna f-ja koja bi trebalo da bude bolja, ali ima neke bugove i ne radi kako treba
  676.     *
  677.     *****************************************************************/
  678.    
  679.    
  680.     enum {NEMA, IMA};
  681.     Pcvor tek, pret;
  682.     Pcvor novaG, noviTek, noviPret, novi;
  683.     short k;
  684.    
  685.     printf("\n\tTablearni prikaz broja pojavljivanja elemenata u listi!\n\n");
  686.    
  687.     if (glava==NULL) {
  688.         printf("\n\n\tLista je prazna. Ne postoji statistika koju treba ispisati!\n\n");
  689.     }
  690.     else {
  691.    
  692.             ini (&novaG);
  693.             tek = glava;
  694.             while (tek!=NULL) {
  695.                 pret = tek;
  696.                
  697.                
  698.                 k = NEMA;
  699.                 noviTek = novaG;
  700.                 while (noviTek!=NULL) {
  701.                     noviPret = noviTek;
  702.                     if (noviPret->broj == pret->broj) k = IMA;
  703.                     noviTek = noviTek->sledeci;
  704.                 }
  705.                
  706.                 if (k==NEMA) {
  707.                     printf("\n\tBroj pojavljivanja broja %d u listi je %d!\n\n", pret->broj, prebroj(glava, pret->broj));
  708.                    
  709.                     if (novaG==NULL) {
  710.                         novaG = (Tcvor *)malloc(sizeof(Tcvor));
  711.                         novaG->broj = pret->broj;
  712.                         novaG->sledeci = NULL;
  713.                     }
  714.                     else {
  715.                         novi = (Tcvor *)malloc(sizeof(Tcvor));
  716.                         novi->broj = pret->broj;
  717.                         novi->sledeci = novaG;
  718.                         novaG = novi;
  719.                     }
  720.                
  721.                
  722.                 }
  723.            
  724.             tek = tek->sledeci;
  725.            
  726.             }
  727.            
  728.            
  729.             osobodiMem(&novaG);
  730.            
  731.         }
  732.        
  733.  
  734.    
  735.    
  736.  
  737. }
  738.  
  739.  
  740. /*char getch() {
  741.     char c,e;
  742.     c = getchar();
  743.     e = getchar();
  744.     return c;
  745. }*/
  746.  
  747.  

posted by del-boy  # 4:57 PM 0 comments

Archives

November 2005   December 2005   January 2006  

This page is powered by Blogger. Isn't yours?