diff --git a/AlgorithmLibrary/BinarySearch.cs b/AlgorithmLibrary/BinarySearch.cs
index fd6ad2d22b33e877a37bbd6c010ecca9ae1f777f..9147f7f4f95c77b109643dee73ece12b7c310731 100644
--- a/AlgorithmLibrary/BinarySearch.cs
+++ b/AlgorithmLibrary/BinarySearch.cs
@@ -16,16 +16,25 @@ namespace AlgorithmLibrary
                 r = A.Length - 1;
             }
             return indexPrvku(A, (int)l, (int)r, k, div);
-        }   
+        }
 
+        /**
+         * Binarni vyhledavani prvniho vyskyt prvku
+         * @param A pole k serazeni
+         * @param l prvni index, na ktery smim sahnout
+         * @param r posledni index, na ktery smim sahnout
+         * @param k hledany prvek
+         * @param div hodnota delici interval z rozsahu 0.5 az 1 
+         * @return vraci index prvku, pokud nalezne, jinak vraci -1
+         */
         private static int indexPrvku(int[] A, int l, int r, int k, float div)
         {
             if (l > r)
                 return -1;
-
-            //int mid = (l + r) / 2;  
+  
             int interval = r - l;
             int rozdel = (int)(interval * (1 - div));
+            //divIndex je index prvku, ktery porovnavame s hledanym prvkem
             int divIndex = l + rozdel;
             if (A[divIndex] == k)
             {
@@ -41,6 +50,7 @@ namespace AlgorithmLibrary
             }
         }
 
+        
         public static int IndexPrvkuFloat(float[] A, float k, float div, int? l = null, int? r = null)
         {
             if (l == null || r == null)
@@ -50,7 +60,15 @@ namespace AlgorithmLibrary
             }
             return indexPrvkuFloat(A, (int)l, (int)r, k, div);
         }
-
+        /**
+         * Binarni vyhledavani s desetinymi hodnotami cisel
+         * @param A pole k serazeni
+         * @param l prvni index, na ktery smim sahnout
+         * @param r posledni index, na ktery smim sahnout
+         * @param k hledany prvek
+         * @param div hodnota delici interval z rozsahu 0.5 az 1 
+         * @return vraci index prvku, pokud nalezne, jinak vraci -1
+         */
         private static int indexPrvkuFloat(float[] A, int l, int r, float k, float div)
         {
             if (l > r)
@@ -79,8 +97,15 @@ namespace AlgorithmLibrary
         {
             return indexPrvkuIterativni(A, k, A.Length - 1, div);
         }
-
-        //NEREKURZIVNI !!!!!
+        /**
+         * Binarni vyhledavani NEREKURZIVNI 
+         * @param A pole k serazeni
+         * @param l prvni index, na ktery smim sahnout
+         * @param r posledni index, na ktery smim sahnout
+         * @param k hledany prvek
+         * @param div hodnota delici interval z rozsahu 0.5 az 1 
+         * @return vraci index prvku, pokud nalezne, jinak vraci -1
+         */
         private static int indexPrvkuIterativni(int[] A, int k, int n, float div)
         {
             int l = 0, r = n - 1;
@@ -106,30 +131,39 @@ namespace AlgorithmLibrary
         }
 
 
-        static public int NejvetsiPrvekNeVetsiNezK(int[] A, int k, int? l = null, int? r = null)
+        static public int NejvetsiPrvekNeVetsiNezK(int[] A, int k, float div, int? l = null, int? r = null)
         {
             if (l == null || r == null)
             {
                 l = 0;
                 r = A.Length - 1;
             }
-            return nejvetsiPrvekNeVetsiNezK(A, (int)l, (int)r, k);
+            return nejvetsiPrvekNeVetsiNezK(A, (int)l, (int)r, k, div);
         }
 
-        //UPRAVENA VARIANTA BEZ PRVKU 
+        /**
+         * Binarni vyhledavani, upravena varianta bez prvku
+         * @param A pole k serazeni
+         * @param l prvni index, na ktery smim sahnout
+         * @param r posledni index, na ktery smim sahnout
+         * @param k hledany prvek
+         * @param div hodnota delici interval z rozsahu 0.5 az 1 
+         * @return vraci index prvku k, pokud nalezne, jinak vraci nejvetsi prvek ne vetsi nez k
+         */
         static private bool neniVetsiNezK(int[] A, int x, int k)
         {
             // neni vetsi nez k, takze je moznym resenim
             return A[x] <= k;
         }
-        static private int nejvetsiPrvekNeVetsiNezK(int[] A, int x, int y, int k)
+        static private int nejvetsiPrvekNeVetsiNezK(int[] A, int x, int y, int k, float div)
         {
             int l = x, r = y;
             int nejlepsi = -1;
             while (l <= r)
             {
-
-                int mid = (l + r) / 2;
+                int interval = r - l;
+                int rozdel = (int)(interval * (1 - div));
+                int mid = l + rozdel;
                 if (neniVetsiNezK(A, mid, k))
                 {
                     nejlepsi = mid;
diff --git a/AlgorithmLibrary/MatrixSearch.cs b/AlgorithmLibrary/MatrixSearch.cs
index 5d49fafaa1ea6510cf6fc3ffd571f6183a0a94e6..8efe5f79a5c45fc84c69eddd57e0702a2b8e12da 100644
--- a/AlgorithmLibrary/MatrixSearch.cs
+++ b/AlgorithmLibrary/MatrixSearch.cs
@@ -8,17 +8,17 @@ namespace AlgorithmLibrary
 {
     internal class MatrixSearch
     {
-        static private int index1 = -1;
-        static private int index2 = -1;
-        static private int counter = 0;
-        static private int[] indexy = new int[4_000_000];
+        static private int index1 = -1; //pozice radku
+        static private int index2 = -1; //pozice sloupce
+        static private int counter = 0; //uruje pozici v poli indexy
+        static private int[] indexy = new int[4_000_000]; //pole pro ulozeni indexu v pripade vice vyskytu
 
+        //binarni vyhledavni - pomocna funkce algoritmu binaryMatice
         private static int indexPrvku(int[] A, int l, int r, int k, float div)
         {
             if (l > r)
                 return -1;
 
-            //int mid = (l + r) / 2;  
             int interval = r - l;
             int rozdel = (int)(interval * (1 - div));
             int divIndex = l + rozdel;
@@ -39,8 +39,11 @@ namespace AlgorithmLibrary
         static private bool neniVetsiNezK(int[] A, int x, int k)
         {
             // neni vetsi nez k, takze je moznym resenim
+            //je tam dalsi vyskyt k?
             return A[x] <= k;
         }
+        //binarni vyhledavni - pomocna funkce algoritmu binaryMatice
+        //v pripade kdy se prvek k vyskytuje cetne, vraci funkce nejvyssi index jednoho z vyskytujicich prvku k v poli
         static private int nejvetsiPrvekNeVetsiNezK(int[] A, int x, int y, int k)
         {
             int l = x, r = y;
@@ -62,15 +65,20 @@ namespace AlgorithmLibrary
             return nejlepsi;
         }
 
-        static public Tuple<int, int> SaddlebackSearch(int[][] A, int k)
+        static public Tuple<int, int> Saddleback(int[][] A, int k)
         {
             index1 = -1;
             index2 = -1;
-            saddlebackSearch(A, k);
+            saddleback(A, k);
             return new Tuple<int, int>(index1, index2);
         }
-
-        static private void saddlebackSearch(int[][] A, int k)
+        /**
+         * Saddleback vyhledavani v matici prvniho vyskytu NEREKURZIVNI
+         * @param A pole k serazeni
+         * @param k hledany prvek
+         * @return algoritmus ulozi pozici vyskytu do promene index1 a index2
+         */
+        static private void saddleback(int[][] A, int k)
         {
             int i = 0;
             int j = A[0].Length - 1;
@@ -96,7 +104,18 @@ namespace AlgorithmLibrary
             indexPrvku2D(A, 0, A.Length - 1, 0, A[0].Length - 1, k, div1, div2);
             return new Tuple<int, int>(index1, index2);
         }
-
+        /**
+        * VyhledavanĂ­ prvku v matici pomoci rozdel a panuj
+        * @param A 2D pole, ve kterem se hleda prvek
+        * @param x prvni index radku na ktery se smi sahnout
+        * @param y posledni index radku, na ktery se smi sahnout
+        * @param u prvni index sloupce na ktery se smi sahnout
+        * @param v posledni index sloupce, na ktery se smi sahnout
+        * @param k hledany prvek
+        * @param div1 hodnota urcujici pomer rozdeleni b1 v ramci radku
+        * @param div2 hodnota urcujici pomer rozdeleni b2 v ramci sloupcu
+        * @return pozice vyskytu se ulozi do globalni promene index1 a index2
+        */
         static private void indexPrvku2D(int[][] A, int x, int y, int u, int v, int k, float div1, float div2)
         {
 
@@ -156,7 +175,17 @@ namespace AlgorithmLibrary
             }
             return result;
         }
-
+        /**
+        * Vyhledavani vice vyskytu prvku v matici pomoci rozdel a panuj
+        * @param A 2D pole, ve kterem se hleda prvek
+        * @param x prvni index radku na ktery se smi sahnout
+        * @param y posledni index radku, na ktery se smi sahnout
+        * @param u prvni index sloupce na ktery se smi sahnout
+        * @param v posledni index sloupce, na ktery se smi sahnout
+        * @param k hledany prvek
+        * @param div hodnota urcujici pomer rozdeleni b v ramci radku i sloupcu
+        * @return pozice vyskytu se ulozi do globalni promene indexy
+        */
         static private void indexyPrvku2D(int[][] A, int x, int y, int u, int v, int k, float div)
         {
             if (u >= v && x >= y)
@@ -203,17 +232,17 @@ namespace AlgorithmLibrary
 
                 indexyPrvku2D(A, x, e1, u, e2, k, div);
 
-                if (!row)
+                if (!row) //pokud to neni radek
                 {
                     indexyPrvku2D(A, e1 + 1, y, u, e2, k, div);
                 }
 
-                if (!column)
+                if (!column) //pokud to neni sloupec
                 {
                     indexyPrvku2D(A, x, e1, e2 + 1, v, k, div);
                 }
 
-                if (!row || !column)
+                if (!row || !column) //pokud to neni radek nebo sloupec
                 {
                     indexyPrvku2D(A, e1 + 1, y, e2 + 1, v, k, div);
                 }
@@ -221,30 +250,6 @@ namespace AlgorithmLibrary
             }
             return;
         }
-
-
-        private static int indexPrvkuSloupec(int[][] A, int column, int x, int y, int k, float div)
-        {
-            if (x > y)
-                return -1;
-
-            //int mid = (l + r) / 2;  
-            int interval = y - x;
-            int rozdel = (int)(interval * (1 - div));
-            int divIndex = x + rozdel;
-            if (A[divIndex][column] == k)
-            {
-                return divIndex;
-            }
-            else if (A[divIndex][column] < k)
-            {
-                return indexPrvkuSloupec(A, column, divIndex + 1, y, k, div);
-            }
-            else
-            {
-                return indexPrvkuSloupec(A, column, x, divIndex - 1, k, div);
-            }
-        }
         
         static public Tuple<int, int> BinaryMatice(int[][] A, int k, float div)
         {
@@ -253,7 +258,17 @@ namespace AlgorithmLibrary
             binaryMatice(A, 0, A.Length - 1, 0, A[0].Length - 1, k, div);
             return new Tuple<int, int>(index1, index2);
         }
-
+        /**
+        * Vyhledavani prvniho vyskytu prvku v matici pomoci binarniho vyhledavani
+        * @param A 2D pole, ve kterem se hleda prvek
+        * @param x prvni index radku na ktery se smi sahnout
+        * @param y posledni index radku, na ktery se smi sahnout
+        * @param u prvni index sloupce na ktery se smi sahnout
+        * @param v posledni index sloupce, na ktery se smi sahnout
+        * @param k hledany prvek
+        * @param div hodnota urcujici pomer rozdeleni b radku a binarniho vyhledvani
+        * @return pozice vyskytu se ulozi do globalni promene indexy
+        */
         static private void binaryMatice(int[][] A, int x, int y, int u, int v, int k, float div)
         {
             if (v < u) return;
@@ -277,8 +292,8 @@ namespace AlgorithmLibrary
                 return;
             }
 
-            int e1 = (int)(x + (y - x) * div);
-            int e2 = nejvetsiPrvekNeVetsiNezK(A[e1], u, v, k);
+            int e1 = (int)(x + (y - x) * div); //urceni radku pomoci parametru div
+            int e2 = nejvetsiPrvekNeVetsiNezK(A[e1], u, v, k); //binarni vyhledavani na radku
 
             if (e2 == -1)
             {
@@ -303,9 +318,11 @@ namespace AlgorithmLibrary
 
         static private bool neniVetsiNezK2(int[] A, int x, int k)
         {
-            // neni vetsi nez k, takze je moznym resenim
+            // je mensi nez k, takze je moznym resenim
             return A[x] < k;
         }
+        //pomocna funkce algoritmu BinaryMaticeVsechny
+        //vrati pozici nejvetsiho prvku na radku, ktery je mensi nez k
         static private int nejvetsiPrvekMensiNezK(int[] A, int x, int y, int k)
         {
             int l = x, r = y;
@@ -326,7 +343,7 @@ namespace AlgorithmLibrary
             }
             if (nejlepsi == -1)
             {
-                nejlepsi = l - 1; // -1 je tu protoze se po vyjiti z funkce pricte 1, takze aby to sedelo;
+                nejlepsi = l - 1; // -1 je tu proto, ze se po vyjiti z funkce na nekterych mistech hlavniho algoritmu pricte 1
             }
             return nejlepsi;
 
@@ -339,6 +356,9 @@ namespace AlgorithmLibrary
             if (prvni) return A[x][sloupec] < k;
             return A[x][sloupec] <= k;
         }
+        //upravene binarni vyhledavani ve sloupci matice
+        //pomocna funkce algoritmu BinaryMaticeVsechny
+        //funkce najde prvni nebo posledni vyskyt podle nastaveni parametru prvni
         static private int prvniPosledniSloupec(int[][] A, int sloupec, int x, int y, int k, bool prvni)
         {
             int l = x, r = y;
@@ -360,6 +380,31 @@ namespace AlgorithmLibrary
             return nejlepsi;
         }
 
+        //binarni vyhledavani ve sloupci matice
+        //pomocna funkce algoritmu BinaryMaticeVsechny
+        private static int indexPrvkuSloupec(int[][] A, int column, int x, int y, int k, float div)
+        {
+            if (x > y)
+                return -1; 
+            int interval = y - x;
+            int rozdel = (int)(interval * (1 - div));
+            int divIndex = x + rozdel;
+            if (A[divIndex][column] == k)
+            {
+                return divIndex;
+            }
+            else if (A[divIndex][column] < k)
+            {
+                return indexPrvkuSloupec(A, column, divIndex + 1, y, k, div);
+            }
+            else
+            {
+                return indexPrvkuSloupec(A, column, x, divIndex - 1, k, div);
+            }
+        }
+
+        //pomocna funkce algoritmu BinaryMaticeVsechny
+        //uklada vsechny pozice vyskytu ve vymezene sekci
         static private void ulozPozicevyksytu(int[][] A, int x, int y, int L, int R, int row, int k, float div)
         {
             for (int i = L; i <= R; i++)
@@ -374,11 +419,11 @@ namespace AlgorithmLibrary
             }
         }
 
-        static public Tuple<int, int>[] BinaryMatice2(int[][] A, int k, float div)
+        static public Tuple<int, int>[] BinaryMaticeVsechny(int[][] A, int k, float div)
         {
             indexy = new int[4_000_000];
             counter = 0;
-            binaryMatice2(A, 0, A.Length - 1, 0, A[0].Length - 1, k, div);
+            binaryMaticeVsechny(A, 0, A.Length - 1, 0, A[0].Length - 1, k, div);
             Tuple<int, int>[] result = new Tuple<int, int>[counter/2];
             for (int i = 0; i < counter; i += 2)
             {
@@ -386,14 +431,22 @@ namespace AlgorithmLibrary
             }
             return result;
         }
-
-        static private void binaryMatice2(int[][] A, int x, int y, int u, int v, int k, float div/*,bool IsFound*/)
+        /**
+        * Vyhledavani vsech vyskytu prvku v matici pomoci binarniho vyhledavani
+        * @param A 2D pole, ve kterem se hleda prvek
+        * @param x prvni index radku na ktery se smi sahnout
+        * @param y posledni index radku, na ktery se smi sahnout
+        * @param u prvni index sloupce na ktery se smi sahnout
+        * @param v posledni index sloupce, na ktery se smi sahnout
+        * @param k hledany prvek
+        * @param div hodnota urcujici pomer rozdeleni b radku a binarniho vyhledvani
+        * @return pozice vyskytu se ulozi do globalni promene indexy
+        */
+        static private void binaryMaticeVsechny(int[][] A, int x, int y, int u, int v, int k, float div)
         {
             int index_L = -1;
             int index_R = -1;
             if (v < u) return;
-            //if (IsFound) return;     ??????
-            //if (index1 != -1 && index2 != -1) return;
             if (x == -1 || y == -1) return;
             if (y < x) return;
 
@@ -402,26 +455,22 @@ namespace AlgorithmLibrary
                 if (x == y && u == v && A[x][u] == k)
                 {
 
-                    indexy[counter++] = x; indexy[counter++] = u;
+                    indexy[counter++] = x; indexy[counter++] = u; //zapsani pozice vyskytu prvku k
                 }
                 else { return; }
-
-
             }
 
             if (x == y)
             {
-
-                //int radek = x;
-                index_R = nejvetsiPrvekNeVetsiNezK(A[x], u, v, k);
+                index_R = nejvetsiPrvekNeVetsiNezK(A[x], u, v, k); //najdi nejpravejsi vyskyt prku a uloz index
                 if (index_R != -1)
                 {
                     if (A[x][index_R] == k)
                     {
-                        index_L = nejvetsiPrvekMensiNezK(A[x], u, v, k) + 1;
+                        index_L = nejvetsiPrvekMensiNezK(A[x], u, v, k) + 1; //pokud se prvek nasel, hledame levou hranici intervalu, na kterem lezi hledane prvky 
                         for (int i = index_L; i <= index_R; i++)
                         {
-                            indexy[counter++] = x; indexy[counter++] = i;
+                            indexy[counter++] = x; indexy[counter++] = i; //zapsani pozice vyskytu prvku k
 
                         }
                     }
@@ -436,21 +485,21 @@ namespace AlgorithmLibrary
             if (e2 == -1)
             {
                 e2 = u - 1;
-                binaryMatice2(A, x, e1 - 1, e2 + 1, v, k, div);
+                binaryMaticeVsechny(A, x, e1 - 1, e2 + 1, v, k, div);
                 return;
             }
             if (A[e1][e2] == k)
             {
                 index_R = e2;
                 index_L = nejvetsiPrvekMensiNezK(A[e1], u, v, k) + 1;
-                ulozPozicevyksytu(A, x, y, index_L, index_R, e1, k, div);
+                ulozPozicevyksytu(A, x, y, index_L, index_R, e1, k, div); //zapsani pozice vyskytu prvku k
                 e2 = index_L - 1;
             }
 
 
-            binaryMatice2(A, e1 + 1, y, u, e2, k, div/*,IsFound*/);
+            binaryMaticeVsechny(A, e1 + 1, y, u, e2, k, div);
             e2 = e2_hranice;
-            binaryMatice2(A, x, e1 - 1, e2 + 1, v, k, div/*,IsFound*/);
+            binaryMaticeVsechny(A, x, e1 - 1, e2 + 1, v, k, div);
 
             return;
 
diff --git a/AlgorithmLibrary/MergeSort.cs b/AlgorithmLibrary/MergeSort.cs
index b2da7b36c767b27cd900c6d079e73a25dbdd45b6..93474d89a3f4ac7ded5946fadb53892fac6b7515 100644
--- a/AlgorithmLibrary/MergeSort.cs
+++ b/AlgorithmLibrary/MergeSort.cs
@@ -21,6 +21,7 @@ namespace AlgorithmLibrary
 		 * @param aux pomocne pole stejne delky jako array
 		 * @param left prvni index na ktery se smi sahnout
 		 * @param right posledni index, na ktery se smi sahnout
+		 * @param div hodnota delici interval z rozsahu 0.5 az 1 
 		 */
         public static void mergeSort(int[] array, int[] aux, int left, int right, float div)
         {
@@ -47,6 +48,7 @@ namespace AlgorithmLibrary
          * @param aux pomocne pole (stejne velikosti jako razene)
          * @param left prvni index, na ktery smim sahnout
          * @param right posledni index, na ktery smim sahnout
+         * @param div hodnota delici interval z rozsahu 0.5 az 1 
          */
         private static void Merge(int[] array, int[] aux, int left, int right, float div)
         {
diff --git a/AlgorithmLibrary/Program.cs b/AlgorithmLibrary/Program.cs
index 2e62bb30b2ed803f76e1d9bf979437317d552877..83bfde951b6cc3343efd8e6f7a9d468b366e036b 100644
--- a/AlgorithmLibrary/Program.cs
+++ b/AlgorithmLibrary/Program.cs
@@ -9,7 +9,7 @@ namespace AlgorithmLibrary
         {
             int[] array = { 5, 2, 9, 1, 5, 6 };
 
-            float div = 0.99f;
+            float div = 0.75f;
 
             Console.WriteLine("\nMERGESORT:\n");
             Console.WriteLine("Před: " + string.Join(", ", array));
@@ -21,7 +21,7 @@ namespace AlgorithmLibrary
             Console.WriteLine("indexPrvku: " + BinarySearch.IndexPrvku(array, 6, div));
             Console.WriteLine("indexPrvku2: " + BinarySearch.IndexPrvkuIterativni(array, 6, div));
             Console.WriteLine("indexPrvkuFloat: " + BinarySearch.IndexPrvkuFloat(new float[] { 1.0f, 2.0f, 5.0f, 5.0f, 6.0f, 9.0f }, 6.0f, div));
-            Console.WriteLine("nejvetsiPrvekNeVetsiNezK: " + BinarySearch.NejvetsiPrvekNeVetsiNezK(array, 6));
+            Console.WriteLine("nejvetsiPrvekNeVetsiNezK: " + BinarySearch.NejvetsiPrvekNeVetsiNezK(array, 6,div));
 
             Console.WriteLine("\n----------------------");
             Console.WriteLine("\nMATICOVÉ VYHLEDÁVÁNÍ\n");
@@ -39,7 +39,7 @@ namespace AlgorithmLibrary
             Console.WriteLine("HledanĂ˝ prvek: " + k);
             Console.WriteLine();
 
-            Tuple<int, int> result = MatrixSearch.SaddlebackSearch(matrix, k);
+            Tuple<int, int> result = MatrixSearch.Saddleback(matrix, k);
             Console.WriteLine($"Saddleback: ({result.Item1}, {result.Item2})");
 
             result = MatrixSearch.IndexPrvku2D(matrix, k, div1, div2);
@@ -55,8 +55,8 @@ namespace AlgorithmLibrary
             result = MatrixSearch.BinaryMatice(matrix2, k, div1);
             Console.WriteLine($"BinaryMatice: ({result.Item1}, {result.Item2})");
 
-            results = MatrixSearch.BinaryMatice2(matrix3, k, div1);
-            Console.WriteLine("BinaryMatice2:");
+            results = MatrixSearch.BinaryMaticeVsechny(matrix3, k, div1);
+            Console.WriteLine("BinaryMaticeVsechny:");
             foreach (var res in results)
             {
                 Console.WriteLine($"({res.Item1}, {res.Item2})");