## Introduction

Searching algorithms are important and fundamental to data structures and computer science in general, enabling efficient data retrieval from different data structures. In C#, these algorithms are used for tasks ranging from simple lookups to complex data processing applications. In simple terms, a search algorithm is a set of procedures used to locate a specific item within a collection of items.

In this article, we are going to learn how to implement the ten most common searching algorithms in C# as well as how to reduce their complexities.

## 1. Linear Search

**Description:**A simple algorithm that checks each element in a list sequentially until the target is found or the list comes to an end.**Use Case:**Good for unsorted or small data sets.

**How Does It Work?**

This algorithm checks each element in the array sequentially. It starts from the first element and compares it with the target value. If it finds a match, it returns the index; if it reaches the end without finding the target, it returns -1, which means the target is not found.

**Complexity: **O(n), where n is the number of elements in the array.

**Example**

```
using System;
class LinearSearchExample
{
static int LinearSearch(int[] arr, int target)
{
for (int i = 0; i < arr.Length; i++)
{
if (arr[i] == target)
return i; // Found
}
return -1; // Not found
}
static void Main()
{
int[] numbers = { 13, 5, 6, 8, 2, 15 };
int target = 8;
int result = LinearSearch(numbers, target);
Console.WriteLine(result != -1 ? $"The target found at index: {result}" : "Not found");
}
}
```

## 2. Binary Search

**Description:**An efficient algorithm that divides a sorted list in half repeatedly until the target is found.**Use Case:**This can be applied only to sorted arrays or lists.

**How Does It Work?**

This algorithm requires the array or list to be sorted. It finds the middle element first and compares it to the target. If the middle element is equal to the target, it returns the index. If the target is less, it recursively searches the left half; if greater, then the right half, and so on, until it finds the target or the halves come to an end.

**Complexity:** O(log n)

**Example**

```
using System;
class BinarySearchExample
{
static int BinarySearch(int[] arr, int target)
{
int left = 0, right = arr.Length - 1;
while (left <= right)
{
int mid = left + (right - left) / 2;
if (arr[mid] == target)
return mid;
if (arr[mid] < target)
left = mid + 1;
else
right = mid - 1;
}
return -1; // Not found
}
static void Main()
{
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int target = 7;
int result = BinarySearch(numbers, target);
Console.WriteLine(result != -1 ? $"Target was found at index: {result}" : "Not found");
}
}
```

## 3. Jump Search

**Description:**A search algorithm that jumps ahead by fixed steps (or blocks) and then performs a linear search within the block.**Use Case:**Useful for sorted arrays where the size is already known.

**How Does It Work?**

This algorithm divides the array into blocks of size √n. It jumps ahead by block size until it finds a block where the target could exist, then performs a linear search within that block.

**Complexity:** O(√n)

**Example**

```
using System;
class JumpSearchExample
{
static int JumpSearch(int[] arr, int target)
{
int n = arr.Length;
int step = (int)Math.Floor(Math.Sqrt(n));
int prev = 0;
while (arr[Math.Min(step, n) - 1] < target)
{
prev = step;
step += (int)Math.Floor(Math.Sqrt(n));
if (prev >= n) return -1;
}
while (arr[prev] < target)
{
prev++;
if (prev == Math.Min(step, n)) return -1;
}
return arr[prev] == target ? prev : -1;
}
static void Main()
{
int[] numbers = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int target = 3;
int result = JumpSearch(numbers, target);
Console.WriteLine(result != -1 ? $"The target was found at index: {result}" : "Not found");
}
}
```

## 4. Exponential Search

**Description:**Combines binary search and exponential search algorithms techniques to find the range of the target and then does a binary search.**Use Case:**Efficient for unbounded or infinite lists.

**How Does It Work?**

This algorithm first finds the range where the target might be located by doubling the index (1, 2, 4, etc.) until the target is less than the current value. It then does a binary search in that range.

**Complexity:** O(log n)

**Example**

```
using System;
class ExponentialSearchExample
{
static int BinarySearch(int[] arr, int left, int right, int target)
{
while (left <= right)
{
int mid = left + (right - left) / 2;
if (arr[mid] == target) return mid;
if (arr[mid] < target) left = mid + 1;
else right = mid - 1;
}
return -1;
}
static int ExponentialSearch(int[] arr, int target)
{
if (arr[0] == target) return 0;
int i = 1;
while (i < arr.Length && arr[i] <= target) i *= 2;
return BinarySearch(arr, i / 2, Math.Min(i, arr.Length - 1), target);
}
static void Main()
{
int[] numbers = { 2, 3, 4, 10, 40, 50, 60, 70, 80, 90, 100 };
int target = 60;
int result = ExponentialSearch(numbers, target);
Console.WriteLine(result != -1 ? $"Found at index: {result}" : "Not found");
}
}
```

## 5. Interpolation Search

**Description:**An improvement to the binary search algorithm that estimates the position of the target based on the value of the target.**Use Case:**Works well for uniformly distributed sorted data.

**How Does It Work?**

This algorithm estimates the position of the target based on its value relative to the elements at the ends of the current range. If the target is found, it returns the index; otherwise, it reduces the search range.

**Complexity:** O(log log n) on average, but can degrade to O(n) in the worst case.

**Example**

```
using System;
class InterpolationSearchExample
{
static int InterpolationSearch(int[] arr, int target)
{
int low = 0, high = arr.Length - 1;
while (low <= high && target >= arr[low] && target <= arr[high])
{
if (low == high)
{
if (arr[low] == target) return low;
return -1;
}
int pos = low + ((target - arr[low]) * (high - low)) / (arr[high] - arr[low]);
if (arr[pos] == target) return pos;
if (arr[pos] < target) low = pos + 1;
else high = pos - 1;
}
return -1;
}
static void Main()
{
int[] numbers = { 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 };
int target = 50;
int result = InterpolationSearch(numbers, target);
Console.WriteLine(result != -1 ? $"Target found at index: {result}" : "Not found");
}
}
```

## 6. Fibonacci Search

**Description:**A search algorithm that uses Fibonacci numbers to divide the array into sections.**Use Case:**Effective for sorted arrays, especially when the size is Fibonacci-like.

**How Does It Work?**

Similar to binary search, it uses Fibonacci numbers to divide the array into sections. It calculates two midpoints based on Fibonacci numbers and reduces the search area accordingly.

**Complexity: **O(log n)

**Example**

```
using System;
class FibonacciSearchExample
{
static int FibonacciSearch(int[] arr, int target)
{
int fibM2 = 0;
int fibM1 = 1;
int fibM = fibM2 + fibM1;
while (fibM < arr.Length)
{
fibM2 = fibM1;
fibM1 = fibM;
fibM = fibM2 + fibM1;
}
int offset = -1;
while (fibM1 > 1)
{
int i = Math.Min(offset + fibM2, arr.Length - 1);
if (arr[i] < target)
{
fibM = fibM1;
fibM1 = fibM2;
fibM2 = fibM - fibM1;
offset = i;
}
else if (arr[i] > target)
{
fibM = fibM2;
fibM1 -= fibM1;
fibM2 = fibM - fibM1;
}
else return i; // Target found.
}
if (fibM1 == 1 && arr[offset + 1] == target) return offset + 1;
return -1;
}
static void Main()
{
int[] numbers = { 10, 22, 35, 40, 45, 50, 80, 82, 85, 90, 95, 100 };
int target = 82;
int result = FibonacciSearch(numbers, target);
Console.WriteLine(result != -1 ? $"Target at index: {result}" : "Not found");
}
}
```

## 7. Ternary Search

**Description:**Similar to binary search, it divides the array into three parts instead of two.**Use Case:**Works on sorted arrays.

**How Does It Work?**

This algorithm divides the array into three parts instead of two. It checks two midpoints and reduces the search operation to one of the three sections based on comparisons with the target.

**Complexity: **O(log n)

**Example**

```
using System;
class TernarySearchExample
{
static int TernarySearch(int[] arr, int left, int right, int target)
{
if (right >= left)
{
int mid1 = left + (right - left) / 3;
int mid2 = right - (right - left) / 3;
if (arr[mid1] == target) return mid1;
if (arr[mid2] == target) return mid2;
if (target < arr[mid1]) return TernarySearch(arr, left, mid1 - 1, target);
else if (target > arr[mid2]) return TernarySearch(arr, mid2 + 1, right, target);
else return TernarySearch(arr, mid1 + 1, mid2 - 1, target);
}
return -1;
}
static void Main()
{
int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int target = 6;
int result = TernarySearch(numbers, 0, numbers.Length - 1, target);
Console.WriteLine(result != -1 ? $"Target was found at index: {result}" : "Not found");
}
}
```

## 8. Knuth-Morris-Pratt (KMP) Algorithm

**Description:**To find a substring within a string.**Use Case:**Efficient for substring search in larger textual data.

**How Does It Work?**

This string searching algorithm preprocesses the pattern to create an array (LPS) or The Longest-Prefix-Suffix Array that helps skip unnecessary comparisons. It scans the text and uses the LPS array to jump back in the pattern when a mismatch occurs.

**Complexity: **O(n + m), where n is the length of the text and m is the length of the pattern.

**Example**

```
using System;
class KMPExample
{
static void KMPSearch(string pat, string txt)
{
int M = pat.Length;
int N = txt.Length;
int[] lps = new int[M];
ComputeLPSArray(pat, M, lps);
int i = 0; // Our index for txt[]
int j = 0; // Our index for pat[]
while (N - i >= M - j)
{
if (pat[j] == txt[i])
{
i++;
j++;
}
if (j == M)
{
Console.WriteLine($"Found pattern at index {i - j}");
j = lps[j - 1];
}
else if (i < N && pat[j] != txt[i])
{
if (j != 0)
j = lps[j - 1];
else
i++;
}
}
}
static void ComputeLPSArray(string pat, int M, int[] lps)
{
int len = 0;
lps[0] = 0;
int i = 1;
while (i < M)
{
if (pat[i] == pat[len])
{
len++;
lps[i] = len;
i++;
}
else
{
if (len != 0)
len = lps[len - 1];
else
{
lps[i] = 0;
i++;
}
}
}
}
static void Main()
{
string txt = "ABABDABACDABABCABAB";
string pat = "ABABCABAB";
KMPSearch(pat, txt);
}
}
```

## 9. Depth-First Search (DFS)

**Description:**Used for searching through graphs and trees.**Use Case:**Useful for traversing data structures like trees and graphs.

**How Does It Work?**

This graph traversal algorithm explores each branch as much as before backtracking. It uses a stack to remember the path and mark visited nodes.

**Complexity:** O(V + E), where V is the number of vertices and E is the number of edges.

**Example**

```
using System;
using System.Collections.Generic;
class DFSExample
{
static void DFS(int vertex, bool[] visited, List<int>[] adj)
{
visited[vertex] = true;
Console.Write(vertex + " ");
foreach (var neighbor in adj[vertex])
{
if (!visited[neighbor])
{
DFS(neighbor, visited, adj);
}
}
}
static void Main()
{
int vertices = 5;
List<int>[] adj = new List<int>[vertices];
for (int i = 0; i < vertices; i++)
adj[i] = new List<int>();
// Add edges
adj[0].Add(1);
adj[0].Add(2);
adj[1].Add(3);
adj[1].Add(4);
adj[2].Add(4);
bool[] visited = new bool[vertices];
Console.WriteLine("DFS starting from vertex 0:");
DFS(0, visited, adj);
}
}
```

## 10. Breadth-First Search (BFS)

**Description:**Used for searching through graphs or trees.**Use Case:**Ideal for finding the shortest path in unweighted graphs and for level-order traversal in trees.

**How Does It Work?**

This algorithm traverses the graph level by level. It uses a queue instead of a stack to explore all neighbors at the present depth before moving on to nodes at the next depth level.

**Complexity:** O(V + E), similar to DFS.

**Example**

```
using System;
using System.Collections.Generic;
class BFSExample
{
static void BFS(int start, List<int>[] adj)
{
bool[] visited = new bool[adj.Length];
Queue<int> queue = new Queue<int>();
visited[start] = true;
queue.Enqueue(start);
while (queue.Count > 0)
{
int vertex = queue.Dequeue();
Console.Write(vertex + " ");
foreach (var neighbor in adj[vertex])
{
if (!visited[neighbor])
{
visited[neighbor] = true;
queue.Enqueue(neighbor);
}
}
}
}
static void Main()
{
int vertices = 5;
List<int>[] adj = new List<int>[vertices];
for (int i = 0; i < vertices; i++)
adj[i] = new List<int>();
// Add edges
adj[0].Add(1);
adj[0].Add(2);
adj[1].Add(3);
adj[1].Add(4);
adj[2].Add(4);
Console.WriteLine("BFS starting from vertex 0:");
BFS(0, adj);
}
}
```

## Reducing the Complexity level of searching algorithms

Reducing the complexity of search algorithms often depends on the specific context and constraints of the problem or use case. Here are some strategies and techniques for optimizing search algorithms.

**Improving Data Structures****Hash Tables:**Using hash tables for searching can reduce the average case time complexity to O(1) for lookups, which is significantly faster than O(n) for linear search.**Self-Balancing Trees:**Structures like AVL trees or Red-Black trees can maintain sorted order with O(log n) search complexity while allowing efficient insertions and deletions.

**Sorting First****Sorting Before Searching:**If you can afford to sort the data first, algorithms like binary search can be used, reducing search complexity to O(log n) after the initial sorting step (O(n log n)).

**Parallelization****Multi-threading:**For large datasets, dividing the search space among multiple threads can lead to faster searches, especially for linear searches or large arrays.

**Indexing****Creating Indices:**In databases, creating indices on frequently searched columns can significantly improve search times, allowing for quicker lookups.

**Caching Results****Memoization:**Storing results of expensive function calls and reusing them can avoid redundant calculations, which is particularly beneficial in recursive searches like DFS.

**Heuristic Approaches****Search Algorithm:**In pathfinding, heuristics can guide the search process, often leading to faster results by prioritizing more promising paths.

**Optimized Search Algorithms****Use of Advanced Algorithms:**Depending on the data type, algorithms like Ternary Search, Interpolation Search, or Exponential Search can be more efficient than traditional methods.

**Pruning****Search Space Pruning:**In algorithms like DFS, implementing pruning strategies (like Alpha-Beta pruning in game trees) can reduce the number of nodes explored.

**Data Preprocessing****Preprocessing the Data:**Structuring data in a way that minimizes the need for exhaustive searching can lead to more efficient algorithms.

## Conclusion

In the world of search algorithms, the choice of method significantly impacts efficiency based on the data structure and specific use case. Algorithms like linear and binary search serve different needs, with linear search being straightforward and simple but inefficient for large datasets, while binary search excels in sorted contexts.

To enhance search performance, various strategies can be employed, such as utilizing efficient data structures, implementing caching, and applying parallel processing. These techniques can hugely reduce time complexity and improve overall system responsiveness.

By understanding both the algorithms and the optimization methods available, you can effectively select and implement the most suitable and fit search solutions for your applications, ensuring optimal performance and user experience.