C programs

Wednesday, December 07, 2005

 

Program za sortiranje niza!

Ovo je moj prvi program za sortiranje niza, pa verovatno nije najoptimizovaniji! Mada sam ga sam pisao (bez upotrebe poznatih algoritama za sortiranje, bar ih nisam tražio, ako sam slučajno potrefio neki dobro je). U stvari ovo je bio domaći, pa samo treba da radi! Videćemo šta ocena kaže! Evo programa!
  1. /*******************************************
  2. *
  3. *  Napisati C program za sortiranje niza
  4. *
  5. ********************************************/
  6.  
  7. #include <stdio.h>
  8. #define MAX_NIZ 50
  9.  
  10. int main()
  11. {
  12.     /*****************************
  13.     *
  14.     *  definisanje enumeracije
  15.     *
  16.     ******************************/
  17.     enum bool {FALSE, TRUE};
  18.  
  19.     /*****************************
  20.     *
  21.     *         Inicijalizacija promenljivih
  22.     *  i, k, j, f su brojaci za petlje
  23.     *  n je broj elemenata niza
  24.     *  a je niz koji se unosi
  25.     *  pom se koristi za zamenu vrednosti
  26.     *  again sluzi za ponavljanje programa
  27.     *  za z postoji detaljno objasnjenje u programu
  28.     *  stop sluzi da zaustavi sortiranje ako je niz sortiran
  29.     *
  30.     ******************************/
  31.     int i, k, f, j, n, z, stop;
  32.     double a[MAX_NIZ], pom;
  33.     char again='y';
  34.  
  35.     /*****************************
  36.     *
  37.     *  Uvodna konverzacija
  38.     *
  39.     *****************************/
  40.     printf("\nProgram za sortiranje niza!\n");
  41.  
  42.     while (again=='y')
  43.     {
  44.            
  45.             /*************************
  46.             *
  47.             *  Inicijalizacija niza
  48.             *
  49.             **************************/
  50.             for (i=0; i<MAX_NIZ; a[i++]=0) ;
  51.  
  52.             /*************************
  53.             *
  54.             *  Unos broja elemenata niza
  55.             *
  56.             *************************/
  57.             printf("Koliko imate elemenata niza? ");
  58.             scanf("%d", &n);
  59.             while ((n<=0) || (n>50))
  60.             {
  61.                 printf("Pogresan unos! Koliko imate elemenata niza? ");
  62.                 scanf("%d", &n);
  63.             }
  64.  
  65.             /*************************
  66.             *
  67.             *  Unos niza
  68.             *
  69.             *************************/
  70.             printf("\nUnos niza: \n");
  71.             for (i=0; i<n; i++)
  72.             {
  73.                 printf("Unesite %d. clan niza: ", i+1);
  74.                 scanf("%lf", &a[i]);
  75.             }
  76.  
  77.             /***********************************
  78.             *
  79.             *  Ako je niz sortiran, petlja se ni ne izvrsava
  80.             *
  81.             ***********************************/
  82.             stop = TRUE;
  83.             for (f=1; f<n; f++) if (a[f-1]>a[f]) stop = FALSE;
  84.             if (stop)   printf("\n\n\tUneli ste vec sortiran niz!");
  85.                 else {
  86.  
  87.                         /************************
  88.                         *
  89.                         *  Sortiranje niza
  90.                         *
  91.                         ************************/
  92.                                 /*******************************
  93.                                 *
  94.                                 *  Glavna petlja prolazi samo do polovine niza
  95.                                 *  jer se istovremeno trazi i najveci i namanji
  96.                                 *  u nizu i stavlja na odgovarajuce mesto
  97.                                 *
  98.                                 *******************************/
  99.                                 for (i=0; i<(n/2); i++)
  100.                                 {
  101.  
  102.                                     /*********************************
  103.                                     *
  104.                                     *  Pomocna petlja se krece unutar dva fixsna
  105.                                     *  clana ('i' i 'n-1-i') i uporedjuje svaki clan
  106.                                     *  iz te unutrasnjosti sa rubnim clanivuma
  107.                                     *  i zamenjuje vrednosti, ako je potrebno.
  108.                                     *  Tako na rubna mesta dolaze najmanji i najveci
  109.                                     *  clanovi iz unutrasnjosti!
  110.                                     *
  111.                                     *********************************/
  112.  
  113.                                     for (k=i+1; k<(n-i); k++)
  114.                                     {
  115.  
  116.  
  117.                                                     /***********************************
  118.                                                     *
  119.                                                     *  Prekida petlju ako je niz vec sortiran
  120.                                                     *
  121.                                                     ***********************************/
  122.                                                     stop = TRUE;
  123.                                                     for (f=1; f<n; f++) if (a[f-1]>a[f]) stop = FALSE;
  124.                                                     if (stop) break;
  125.  
  126.                                                     /****************************************
  127.                                                     *
  128.                                                     *  Ispisuje trenutno stanje niza pre prolaska kroz petlju
  129.                                                     *
  130.                                                     *****************************************/
  131.                                                     printf("\nTrenutno stanje za i = %d i k = %d!\n", i, k);
  132.                                                     for (j=0; j<n; printf("%.2lf\t", a[j++]) ) ;
  133.  
  134.  
  135.                                                     /***************************************************
  136.                                                     *
  137.                                                     *  Moze da se desi da ukoliko clan koji posmatramo nije manji
  138.                                                     *  od clana 'i', a jeste veci od clana 'n-1-i'. Ako je tako moze
  139.                                                     *  da se desi da posle zamene novi clan koji se nalazio na
  140.                                                     *  lokaciji 'n-1-i' bude manji od clana na lokaciji 'i', a ta provera
  141.                                                     *  je vec zavrsena. Zvog toga se uvodi promenljiva z1, koja
  142.                                                     *  pamti da li se druga zamena vrednosti desila. Ukoliko jeste
  143.                                                     *  ponavlja se provera da li je taj novi clan manji od clana 'i'.
  144.                                                     *
  145.                                                     *  Na pocetku z1 ima vrednost FALSE jer se ni jedna zamena nije
  146.                                                     *  izvrsila. Kasnije moze da promeni vrednost u drugoj if naredbi!
  147.                                                     *
  148.                                                     *
  149.                                                     ***************************************************/
  150.                                                     z = FALSE;
  151.  
  152.                                                     /*************************************************
  153.                                                     *
  154.                                                     *  Ako je clan koji posmatramo manji od clana koji se nalazi na mestu
  155.                                                     *  gde treba da bude najmanji, vrsi se zamena vrednosti!
  156.                                                     *
  157.                                                     *************************************************/
  158.                                                     if (a[k]<a[i])
  159.                                                     {
  160.                                                         pom = a[k];
  161.                                                         a[k] = a[i];
  162.                                                         a[i] = pom;
  163.                                                     }
  164.  
  165.  
  166.                                                     /*************************************************
  167.                                                     *
  168.                                                     *  Ako je clan koji posmatramo veci od clana koji se nalazi na mestu
  169.                                                     *  gde treba da bude najveci, vrsi se zamena vrednosti, i postalja se
  170.                                                     *  promenliva z1 na TRUE da bi se posle ponovila prva if naredba!
  171.                                                     *
  172.                                                     *************************************************/
  173.                                                     if (a[k]>a[n-1-i])
  174.                                                     {
  175.                                                         pom = a[k];
  176.                                                         a[k] = a[n-1-i];
  177.                                                         a[n-1-i] = pom;
  178.                                                         z = TRUE;
  179.                                                     }
  180.  
  181.                                                     /************************************************
  182.                                       &;nbsp;             *
  183.                                                     *  z1 pamti da i se prethodna if naredba izvrsila. Ukoliko jeste ponovo
  184.                                                     *  proverava da li je clan koji posmatramo veci od clana koji se
  185.                                                     *  nalazi na mestu gde treba da se nadje  najveci! Ako jeste, ponovo
  186.                                                     *  proverava da li je tekuci clan manji od clana koji se nalazi
  187.                                                     *  na mestu gde treba da bude najmanji i ako jeste, menja se vrednost!
  188.                                                     *
  189.                                                     ************************************************/
  190.                                                     if (z)
  191.                                                     {
  192.                                                         if (a[k]<a[i])
  193.                                                         {
  194.                                                             pom = a[k];
  195.                                                             a[k] = a[i];
  196.                                                             a[i] = pom;
  197.                                                             }
  198.                                                     }
  199.  
  200.                                     }
  201.                             }
  202.                     }
  203.  
  204.             /*******************
  205.             *
  206.             *  Ispis sortiranog niza
  207.             *
  208.             *******************/
  209.             printf("\n\nSortirani niz: \n");
  210.             for (i=0; i<n; printf("%.2lf\t", a[i++])) ;
  211.  
  212.  
  213.            
  214.             /************************************************
  215.             *
  216.             *  Provera da li korinik zeli da ponovi program
  217.             *
  218.             ************************************************/
  219.             printf("\nDa li zelite da ponovite program? (y/n) ");
  220.             scanf("%c", &again);
  221.             scanf("%c", &again);
  222.             while (again!='y' && again !='n') {
  223.                 printf("Pogresan unos! Da li zelite da ponovite program? (y/n) ");
  224.                 scanf("%c", &again);
  225.                 scanf("%c", &again);
  226.                 }
  227.  
  228.     }
  229.  
  230.     /***********************
  231.     *
  232.     *  KRAJ PROGRAMA
  233.     *
  234.     ************************/
  235.     printf("\n\n**KRAJ PROGRAMA**\n\n");
  236.     return 0;
  237. }

posted by del-boy  # 4:15 AM
Comments: Post a Comment



<< Home

Archives

November 2005   December 2005   January 2006  

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