GOD bless universes

MehrajLatifli · MehrajLatifli · commit 0580a7873799 · 2023-12-18T13:34:02.000+04:00
diff --git a/Algorithms/Searching algorithms/BinarySearch/BinarySearchAlgorithm.cs b/Algorithms/Searching algorithms/BinarySearch/BinarySearchAlgorithm.cs
@@ -4,14 +4,14 @@
 
 namespace BinarySearch
 {
-    public static class BinarySearchAlgorithm
+    public static class BinarySearchAlgorithm<T> where T : IItem
     {
-        public static int Search(List<Item> items, int x)
+        public static async Task <int> Search(List<T> items, int x)
         {
-            return BinarySearchRecursive(items, x, 0, items.Count - 1);
+            return await BinarySearchRecursive(items, x, 0, items.Count - 1);
         }
 
-        private static int BinarySearchRecursive(List<Item> items, int target, int left, int right)
+        private static async Task <int> BinarySearchRecursive(List<T> items, int target, int left, int right)
         {
 
             if (left <= right)
@@ -24,11 +24,11 @@ private static int BinarySearchRecursive(List<Item> items, int target, int left,
                 }
                 else if (items[middle].Id < target)
                 {
-                    return BinarySearchRecursive(items, target, middle + 1, right);
+                    return await BinarySearchRecursive(items, target, middle + 1, right);
                 }
                 else
                 {
-                    return BinarySearchRecursive(items, target, left, middle - 1);
+                    return await BinarySearchRecursive(items, target, left, middle - 1);
                 }
             }
 
diff --git a/Algorithms/Searching algorithms/JumpSearch/JumpSearch.csproj b/Algorithms/Searching algorithms/JumpSearch/JumpSearch.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Shares\Data\Data.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Algorithms/Searching algorithms/JumpSearch/JumpSearchAlgorithm.cs b/Algorithms/Searching algorithms/JumpSearch/JumpSearchAlgorithm.cs
@@ -0,0 +1,42 @@
+﻿using Data;
+
+namespace JumpSearch
+{
+    public static class JumpSearchAlgorithm<T> where T : IItem
+    {
+        public static  async Task<int> Search(List<T> items, int targetId)
+        {
+            int n = items.Count;
+            int step = (int)Math.Sqrt(n);
+            int prev = 0;
+
+            while (items[Math.Min(step, n) - 1].Id < targetId)
+            {
+                prev = step;
+                step += (int)Math.Sqrt(n);
+
+                if (prev >= n)
+                {
+                    return -1; 
+                }
+            }
+
+            while (items[prev].Id < targetId)
+            {
+                prev++;
+
+                if (prev == Math.Min(step, n))
+                {
+                    return -1; 
+                }
+            }
+
+            if (items[prev].Id == targetId)
+            {
+                return prev;
+            }
+
+            return -1;
+        }
+    }
+}
diff --git a/Algorithms/Searching algorithms/LinearSearch/LinearSearchAlgorithm.cs b/Algorithms/Searching algorithms/LinearSearch/LinearSearchAlgorithm.cs
@@ -7,10 +7,10 @@
 
 namespace LinearSearch
 {
-    public static class LinearSearchAlgorithm
+    public static class LinearSearchAlgorithm<T> where T : IItem
     {
 
-        public static int Search(List<Item> items, int x)
+        public static async Task<int> Search(List<T> items, int x)
         {
             for (int i = 0; i < items.Count; i++)
             {
diff --git a/Algorithms/Searching algorithms/TernarySearch/TernarySearch.csproj b/Algorithms/Searching algorithms/TernarySearch/TernarySearch.csproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net7.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\..\Shares\Data\Data.csproj" />
+  </ItemGroup>
+
+</Project>
diff --git a/Algorithms/Searching algorithms/TernarySearch/TernarySearchAlgorithm.cs b/Algorithms/Searching algorithms/TernarySearch/TernarySearchAlgorithm.cs
@@ -0,0 +1,40 @@
+﻿using Data;
+
+namespace TernarySearch
+{
+    public class TernarySearchAlgorithm<T> where T : IItem
+    {
+        public static async Task<int> Search(List<T> items, int left, int right, int targetId)
+        {
+            if (left <= right)
+            {
+                int mid1 = left + (right - left) / 3;
+                int mid2 = right - (right - left) / 3;
+
+                if (items[mid1].Id == targetId)
+                {
+                    return mid1;
+                }
+                if (items[mid2].Id == targetId)
+                {
+                    return mid2;
+                }
+
+                if (targetId < items[mid1].Id)
+                {
+                    return await Search(items, left, mid1 - 1, targetId);
+                }
+                else if (targetId > items[mid2].Id)
+                {
+                    return await Search(items, mid2 + 1, right, targetId);
+                }
+                else
+                {
+                    return await Search(items, mid1 + 1, mid2 - 1, targetId);
+                }
+            }
+
+            return -1; // Not found
+        }
+    }
+}
diff --git a/Algorithms/Sorting algorithms/MergeSort/MergeSortAlgorithm.cs b/Algorithms/Sorting algorithms/MergeSort/MergeSortAlgorithm.cs
@@ -17,7 +17,7 @@ await Task.Run(() =>
             return items;
         }
 
-        static void MergeSort(List<T> items)
+        static async Task MergeSort(List<T> items)
         {
             int n = items.Count;
 
@@ -28,10 +28,14 @@ static void MergeSort(List<T> items)
                 List<T> left = items.GetRange(0, mid);
                 List<T> right = items.GetRange(mid, n - mid);
 
-                MergeSort(left);
-                MergeSort(right);
+                await Task.WhenAll(
+                    MergeSort(left),
+                    MergeSort(right)
+                );
 
                 Merge(items, left, right);
+
+
             }
         }
 
@@ -43,7 +47,6 @@ static void Merge(List<T> items, List<T> left, List<T> right)
 
             while (i < leftCount && j < rightCount)
             {
-               
                 if (left[i].Id < right[j].Id)
                 {
                     items[k] = left[i];
@@ -57,15 +60,13 @@ static void Merge(List<T> items, List<T> left, List<T> right)
                 k++;
             }
 
-          
             while (i < leftCount)
             {
                 items[k] = left[i];
                 i++;
                 k++;
             }
 
-           
             while (j < rightCount)
             {
                 items[k] = right[j];
diff --git a/Algorithms/Sorting algorithms/QuickSort/QuickSortAlgorithm.cs b/Algorithms/Sorting algorithms/QuickSort/QuickSortAlgorithm.cs
@@ -9,26 +9,28 @@ public static class QuickSortAlgorithm<T> where T : IItem
     {
         public static async Task<List<T>> Sorting(List<T> items)
         {
-            await Task.Run(() =>
+            await Task.Run( async() =>
             {
-                QuickSort(items, 0, items.Count - 1);
+                 await  QuickSort(items, 0, items.Count - 1); // Wait for the asynchronous sorting to complete.
             });
 
             return items;
         }
 
-        static void QuickSort(List<T> items, int low, int high)
+        static async Task QuickSort(List<T> items, int low, int high)
         {
             if (low < high)
             {
-                int partitionIndex = Partition(items, low, high);
+                int partitionIndex = Partition(items, low, high).Result;
 
-                QuickSort(items, low, partitionIndex - 1);
-                QuickSort(items, partitionIndex + 1, high);
+                Task.WaitAll(
+                    Task.Run(() => QuickSort(items, low, partitionIndex - 1)),
+                    Task.Run(() => QuickSort(items, partitionIndex + 1, high))
+                );
             }
         }
 
-        static int Partition(List<T> items, int low, int high)
+        static async Task<int> Partition(List<T> items, int low, int high)
         {
             T pivot = items[high];
             int i = low - 1;
@@ -38,19 +40,23 @@ static int Partition(List<T> items, int low, int high)
                 if (items[j].Id < pivot.Id)
                 {
                     i++;
-                    Swap(items, i, j);
+                    await Swap(items, i, j);
                 }
             }
 
-            Swap(items, i + 1, high);
+            await Swap(items, i + 1, high);
             return i + 1;
         }
 
-        static void Swap(List<T> items, int i, int j)
+        static async Task Swap(List<T> items, int i, int j)
         {
-            T temp = items[i];
-            items[i] = items[j];
-            items[j] = temp;
+            await Task.Run(() =>
+            {
+                T temp = items[i];
+                items[i] = items[j];
+                items[j] = temp;
+            });
         }
+
     }
 }
diff --git a/DataStructuresAndAlgorithms.sln b/DataStructuresAndAlgorithms.sln
@@ -41,7 +41,11 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "SelectionSort", "Algorithms
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Stack", "Algorithms\Custom Abstract data types algorithms\Stack\Stack.csproj", "{9BE7A02A-F512-442B-8830-E105E611B087}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Queue", "Algorithms\Custom Abstract data types algorithms\Queue\Queue.csproj", "{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735}"
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Queue", "Algorithms\Custom Abstract data types algorithms\Queue\Queue.csproj", "{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TernarySearch", "Algorithms\Searching algorithms\TernarySearch\TernarySearch.csproj", "{DABF98E7-54A7-4A1C-8679-F2804A23FC97}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "JumpSearch", "Algorithms\Searching algorithms\JumpSearch\JumpSearch.csproj", "{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B}"
 EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
@@ -101,6 +105,14 @@ Global
 		{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735}.Release|Any CPU.Build.0 = Release|Any CPU
+		{DABF98E7-54A7-4A1C-8679-F2804A23FC97}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{DABF98E7-54A7-4A1C-8679-F2804A23FC97}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{DABF98E7-54A7-4A1C-8679-F2804A23FC97}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{DABF98E7-54A7-4A1C-8679-F2804A23FC97}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -123,6 +135,8 @@ Global
 		{E93874F0-B0C5-4A04-9852-0D293BB86A0B} = {90AAC62F-6373-40D6-B54E-B5BF7AC25166}
 		{9BE7A02A-F512-442B-8830-E105E611B087} = {97F18839-2773-43C8-A7C7-1E05888E8312}
 		{45E2DA40-FC03-43A2-AF7B-F3E8F94CE735} = {97F18839-2773-43C8-A7C7-1E05888E8312}
+		{DABF98E7-54A7-4A1C-8679-F2804A23FC97} = {EDA88687-37E5-4CB0-B165-99C234663DCC}
+		{9B2B98BB-90C5-42BE-BDAA-EAC35F9DF41B} = {EDA88687-37E5-4CB0-B165-99C234663DCC}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {4CCF8022-6EFC-48B8-91FE-D4EA5C7496E0}
diff --git a/Presentations/DataStructuresAndAlgorithms/DataStructuresAndAlgorithms.csproj b/Presentations/DataStructuresAndAlgorithms/DataStructuresAndAlgorithms.csproj
@@ -12,7 +12,9 @@
     <ProjectReference Include="..\..\Algorithms\Custom Abstract data types algorithms\Queue\Queue.csproj" />
     <ProjectReference Include="..\..\Algorithms\Custom Abstract data types algorithms\Stack\Stack.csproj" />
     <ProjectReference Include="..\..\Algorithms\Searching algorithms\BinarySearch\BinarySearch.csproj" />
+    <ProjectReference Include="..\..\Algorithms\Searching algorithms\JumpSearch\JumpSearch.csproj" />
     <ProjectReference Include="..\..\Algorithms\Searching algorithms\LinearSearch\LinearSearch.csproj" />
+    <ProjectReference Include="..\..\Algorithms\Searching algorithms\TernarySearch\TernarySearch.csproj" />
     <ProjectReference Include="..\..\Algorithms\Sorting algorithms\BubbleSort\BubbleSort.csproj" />
     <ProjectReference Include="..\..\Algorithms\Sorting algorithms\InsertionSort\InsertionSort.csproj" />
     <ProjectReference Include="..\..\Algorithms\Sorting algorithms\MergeSort\MergeSort.csproj" />
diff --git a/Presentations/DataStructuresAndAlgorithms/Program.cs b/Presentations/DataStructuresAndAlgorithms/Program.cs
diff --git a/Shares/RandomData/RandomDataFilling.cs b/Shares/RandomData/RandomDataFilling.cs

Original file line number	Diff line number	Diff line change
`@@ -4,14 +4,14 @@`
`4`	`4`
`5`	`5`	`namespace BinarySearch`
`6`	`6`	`{`
`7`		`- public static class BinarySearchAlgorithm`
	`7`	`+ public static class BinarySearchAlgorithm<T> where T : IItem`
`8`	`8`	`{`
`9`		`- public static int Search(List<Item> items, int x)`
	`9`	`+ public static async Task <int> Search(List<T> items, int x)`
`10`	`10`	`{`
`11`		`- return BinarySearchRecursive(items, x, 0, items.Count - 1);`
	`11`	`+ return await BinarySearchRecursive(items, x, 0, items.Count - 1);`
`12`	`12`	`}`
`13`	`13`
`14`		`- private static int BinarySearchRecursive(List<Item> items, int target, int left, int right)`
	`14`	`+ private static async Task <int> BinarySearchRecursive(List<T> items, int target, int left, int right)`
`15`	`15`	`{`
`16`	`16`
`17`	`17`	`if (left <= right)`
`@@ -24,11 +24,11 @@ private static int BinarySearchRecursive(List<Item> items, int target, int left,`
`24`	`24`	`}`
`25`	`25`	`else if (items[middle].Id < target)`
`26`	`26`	`{`
`27`		`- return BinarySearchRecursive(items, target, middle + 1, right);`
	`27`	`+ return await BinarySearchRecursive(items, target, middle + 1, right);`
`28`	`28`	`}`
`29`	`29`	`else`
`30`	`30`	`{`
`31`		`- return BinarySearchRecursive(items, target, left, middle - 1);`
	`31`	`+ return await BinarySearchRecursive(items, target, left, middle - 1);`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -7,10 +7,10 @@`
`7`	`7`
`8`	`8`	`namespace LinearSearch`
`9`	`9`	`{`
`10`		`- public static class LinearSearchAlgorithm`
	`10`	`+ public static class LinearSearchAlgorithm<T> where T : IItem`
`11`	`11`	`{`
`12`	`12`
`13`		`- public static int Search(List<Item> items, int x)`
	`13`	`+ public static async Task<int> Search(List<T> items, int x)`
`14`	`14`	`{`
`15`	`15`	`for (int i = 0; i < items.Count; i++)`
`16`	`16`	`{`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ await Task.Run(() =>`
`17`	`17`	`return items;`
`18`	`18`	`}`
`19`	`19`
`20`		`- static void MergeSort(List<T> items)`
	`20`	`+ static async Task MergeSort(List<T> items)`
`21`	`21`	`{`
`22`	`22`	`int n = items.Count;`
`23`	`23`
`@@ -28,10 +28,14 @@ static void MergeSort(List<T> items)`
`28`	`28`	`List<T> left = items.GetRange(0, mid);`
`29`	`29`	`List<T> right = items.GetRange(mid, n - mid);`
`30`	`30`
`31`		`- MergeSort(left);`
`32`		`- MergeSort(right);`
	`31`	`+ await Task.WhenAll(`
	`32`	`+ MergeSort(left),`
	`33`	`+ MergeSort(right)`
	`34`	`+ );`
`33`	`35`
`34`	`36`	`Merge(items, left, right);`
	`37`	`+`
	`38`	`+`
`35`	`39`	`}`
`36`	`40`	`}`
`37`	`41`
`@@ -43,7 +47,6 @@ static void Merge(List<T> items, List<T> left, List<T> right)`
`43`	`47`
`44`	`48`	`while (i < leftCount && j < rightCount)`
`45`	`49`	`{`
`46`		`-`
`47`	`50`	`if (left[i].Id < right[j].Id)`
`48`	`51`	`{`
`49`	`52`	`items[k] = left[i];`
`@@ -57,15 +60,13 @@ static void Merge(List<T> items, List<T> left, List<T> right)`
`57`	`60`	`k++;`
`58`	`61`	`}`
`59`	`62`
`60`		`-`
`61`	`63`	`while (i < leftCount)`
`62`	`64`	`{`
`63`	`65`	`items[k] = left[i];`
`64`	`66`	`i++;`
`65`	`67`	`k++;`
`66`	`68`	`}`
`67`	`69`
`68`		`-`
`69`	`70`	`while (j < rightCount)`
`70`	`71`	`{`
`71`	`72`	`items[k] = right[j];`
Original file line number	Diff line number	Diff line change
`@@ -9,26 +9,28 @@ public static class QuickSortAlgorithm<T> where T : IItem`
`9`	`9`	`{`
`10`	`10`	`public static async Task<List<T>> Sorting(List<T> items)`
`11`	`11`	`{`
`12`		`- await Task.Run(() =>`
	`12`	`+ await Task.Run( async() =>`
`13`	`13`	`{`
`14`		`- QuickSort(items, 0, items.Count - 1);`
	`14`	`+ await QuickSort(items, 0, items.Count - 1); // Wait for the asynchronous sorting to complete.`
`15`	`15`	`});`
`16`	`16`
`17`	`17`	`return items;`
`18`	`18`	`}`
`19`	`19`
`20`		`- static void QuickSort(List<T> items, int low, int high)`
	`20`	`+ static async Task QuickSort(List<T> items, int low, int high)`
`21`	`21`	`{`
`22`	`22`	`if (low < high)`
`23`	`23`	`{`
`24`		`- int partitionIndex = Partition(items, low, high);`
	`24`	`+ int partitionIndex = Partition(items, low, high).Result;`
`25`	`25`
`26`		`- QuickSort(items, low, partitionIndex - 1);`
`27`		`- QuickSort(items, partitionIndex + 1, high);`
	`26`	`+ Task.WaitAll(`
	`27`	`+ Task.Run(() => QuickSort(items, low, partitionIndex - 1)),`
	`28`	`+ Task.Run(() => QuickSort(items, partitionIndex + 1, high))`
	`29`	`+ );`
`28`	`30`	`}`
`29`	`31`	`}`
`30`	`32`
`31`		`- static int Partition(List<T> items, int low, int high)`
	`33`	`+ static async Task<int> Partition(List<T> items, int low, int high)`
`32`	`34`	`{`
`33`	`35`	`T pivot = items[high];`
`34`	`36`	`int i = low - 1;`
`@@ -38,19 +40,23 @@ static int Partition(List<T> items, int low, int high)`
`38`	`40`	`if (items[j].Id < pivot.Id)`
`39`	`41`	`{`
`40`	`42`	`i++;`
`41`		`- Swap(items, i, j);`
	`43`	`+ await Swap(items, i, j);`
`42`	`44`	`}`
`43`	`45`	`}`
`44`	`46`
`45`		`- Swap(items, i + 1, high);`
	`47`	`+ await Swap(items, i + 1, high);`
`46`	`48`	`return i + 1;`
`47`	`49`	`}`
`48`	`50`
`49`		`- static void Swap(List<T> items, int i, int j)`
	`51`	`+ static async Task Swap(List<T> items, int i, int j)`
`50`	`52`	`{`
`51`		`- T temp = items[i];`
`52`		`- items[i] = items[j];`
`53`		`- items[j] = temp;`
	`53`	`+ await Task.Run(() =>`
	`54`	`+ {`
	`55`	`+ T temp = items[i];`
	`56`	`+ items[i] = items[j];`
	`57`	`+ items[j] = temp;`
	`58`	`+ });`
`54`	`59`	`}`
	`60`	`+`
`55`	`61`	`}`
`56`	`62`	`}`