From 48996b5131030718afab31c2e6b256db7b2128e0 Mon Sep 17 00:00:00 2001
From: dem0091 <klara.nieslanikova.st@vsb.cz>
Date: Wed, 30 Apr 2025 14:22:25 +0200
Subject: [PATCH] Add comments
---
AlgorithmLibrary/BinarySearch.cs | 58 ++++++++---
AlgorithmLibrary/MatrixSearch.cs | 171 ++++++++++++++++++++-----------
AlgorithmLibrary/MergeSort.cs | 2 +
AlgorithmLibrary/Program.cs | 10 +-
4 files changed, 163 insertions(+), 78 deletions(-)
diff --git a/AlgorithmLibrary/BinarySearch.cs b/AlgorithmLibrary/BinarySearch.cs
index fd6ad2d..9147f7f 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 5d49faf..8efe5f7 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 b2da7b3..93474d8 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 2e62bb3..83bfde9 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})");
--
GitLab