View difference between Paste ID: FTr2Y8dm and 45CG9V3a

 #include <stdio.h>
 #include <stdlib.h>
-//Koktejlove razeni matice matice
+//Domaci ukol 2 - Tomas Biheler - oprava
-//Neni to zatim dodelane uplne podle zadani ale už to aspon (neefektivne) funguje.
+//Koktejlove razeni matice.
 //pouziva jeden vnejsi a jeden vnitrni cyklus.
 //neprobublava setridene casti matice.
 
 //Celkovy cas straveny resenim - cca. 6 hodin.
 int main()
 {
-    int zpracovatCisel = celkemCisel;
+
     int pocetRadku = 11;
-    int matice[pocetRadku][pocetSloupcu];
+
-    int vnejsiIterace;
+
-    int vnitrniIterace;
+    int zpracovatCisel = celkemCisel; //pracovni hodnota, ktera se postupne zmensuje s tim, jak je matice serazenejsi...
     int smer = 1; //1 = dolu; -1 = nahoru;
     int matice[pocetRadku][pocetSloupcu]; //jedna matice, dle zadani
     int vnejsiIterace = 0; //dokud neni serazeno
     int vnitrniIterace; //probublavani
     srand(time(NULL));
 
     int serazeno = 0;
 
     //naplnìní matice a jeji vypis
     printf("\nNahodne vygenerovana matice:\n\n");
     for(int i = 0; i < pocetRadku; ++i)
     {
         for(int j = 0; j < pocetSloupcu; ++j)
         {
             matice[i][j] = rand() % 100;
             printf("%02i ", matice[i][j]);
-    while(serazeno == 0)
+
         printf("\n");
     }
-        for(vnitrniIterace = 0; vnitrniIterace < zpracovatCisel; vnitrniIterace += smer)
+
     //serazeni matice
     while(serazeno == 0) //jeden vnejsi cyklus
     {
         int nastaloPrehozeni = 0;
         for(vnitrniIterace = celkemCisel - zpracovatCisel; vnitrniIterace < zpracovatCisel; vnitrniIterace += smer) //jeden vnitrni cyklus
         {
             int k = vnitrniIterace / pocetSloupcu; //sloupcova pozice
             int l = vnitrniIterace % pocetSloupcu; //radkova pozice
-                //printf("sort P:%02i:%02i - V: %02i, R: %i\n", k, l, matice[k][l], zpracovatCisel);
+
 
             if(smer == 1) //zleva doprava dolu...
             {
                 if(l < pocetSloupcu-1) //stejny radek
                 {
                     if((matice[k][l]) > matice[k][l+1])
                     {
                         int temp = matice[k][l];
                         matice[k][l] = matice[k][l+1];
                         matice[k][l+1] = temp;
                         nastaloPrehozeni = 1;
                     }
                 }
                 if(k < pocetRadku-1 && l == pocetSloupcu -1) //posledni polozka neposledniho radku
                 {
                     if((matice[k][l]) > matice[k+1][0]) //posledni polozka aktualniho radku s prvni polozkou nasledujiciho
                     {
                         int temp = matice[k][l];
                         matice[k][l] = matice[k+1][0];
                         matice[k+1][0] = temp;
                         nastaloPrehozeni = 1;
-                if(k == pocetRadku-1 && l == pocetSloupcu-1)
+
                 }
-                    //posledni polozka iterace, zmena smeru
+                if(vnitrniIterace == zpracovatCisel-1) //posledni polozka iterace smerem dolu, zmena smeru
-                    break;
+
                     smer = -1;
                 }
-            if(smer == -1)
+
             if(smer == -1) //zprava doleva nahoru
             {
                 if(l > 0) //stejny radek
-                if(k == pocetRadku-1 && l == pocetSloupcu-1)
+
                     if((matice[k][l]) < matice[k][l-1])
-                    //posledni polozka iterace
+
-                    break;
+
                         matice[k][l] = matice[k][l-1];
                         matice[k][l-1] = temp;
                         nastaloPrehozeni = 1;
                     }
                 }
                 if(l == 0 && k > 0) //prvni polozka neprvniho radku
                 {
                     if((matice[k][l]) < matice[k-1][pocetSloupcu-1]) //posledni polozka aktualniho radku s prvni polozkou nasledujiciho
                     {
                         int temp = matice[k][l];
                         matice[k][l] = matice[k-1][pocetSloupcu-1];
                         matice[k-1][pocetSloupcu-1] = temp;
                         nastaloPrehozeni = 1;
                     }
                 }
                 if(vnitrniIterace == 0 && smer == -1) //posledni polozka iterace smerem nahoru, konec iterace
                 {
                     //zpatky u prvni polozky
                     smer = 1;
-        //printf("\nVnitrnich iteraci: %i", vnitrniIterace); //dukaz, ze to neprobublava celou matici
+                    break; //ukonci iteraci a zacne novou
                 }
             }
             if( matice[k][l] > 100) //nekde to preteklo a tohle se da pouzit na zjisteni daneho mista
             {
                 printf("val err P:%02i:%02i - V: %02i\n", k, l, matice[k][l]);
             }
         }
         ++vnejsiIterace;
         --zpracovatCisel; //omezení bublani serazenou casti matice
 
         if(nastaloPrehozeni == 1)
         {
             continue;
         }
-    printf("\n\nserazeno v %i iteracich:\n", vnejsiIterace);
+
         {
             serazeno = 1;
         }
     }
 
     //vypis serazene matice
     printf("\n\nserazeno shaker/cocktail sortem v %i iteracich (vnejsiho cyklu):\n\n", vnejsiIterace);
     for(int i = 0; i < pocetRadku; ++i)
     {
         for(int j = 0; j < pocetSloupcu; ++j)
         {
             printf("%02i ", matice[i][j]);
         }
         printf("\n");
     }
 
     return 0;
 }