Sorting Algorithms

These put things in order, like arranging numbers from smallest to largest or putting words in alphabetical order.

• Bubble Sort: Looks at pairs of items and swaps them if they’re in the wrong order.
• Merge Sort: Splits the items into smaller groups, sorts them, and then puts them back together in order.
• Quick Sort: Picks a “pivot” item and moves everything smaller to one side and everything larger to the other, then repeats this process.

Bubble Sort

public void BubbleSort(int[] arr)
{
    int n = arr.Length;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (arr[j] > arr[j + 1])
            {
                int temp = arr[j];
                arr[j] = arr[j + 1];
                arr[j + 1] = temp;
            }
        }
    }
}

Example usage

int[] arr = { 64, 34, 25, 12, 22, 11, 90 };
BubbleSort(arr);
Console.WriteLine("Bubble Sorted array is:");
foreach (int item in arr)
{
    Console.Write(item + " ");
}

Searching Algorithms

These help find something in a bunch of stuff, like locating a specific book in a library.

• Linear Search: Looks at each item one by one until it finds what it’s looking for.
• Binary Search: Divides the search area in half each time, which is faster but needs the items to be in order.
• Hashing: Uses a special formula to quickly find where something is stored, like using a code to find a secret message.

Binary Search (requires sorted array)

public int BinarySearch(int[] arr, int target)
{
    int low = 0;
    int high = arr.Length - 1;
    while (low <= high)
    {
        int mid = (low + high) / 2;
        if (arr[mid] == target)
            return mid;
        else if (arr[mid] < target)
            low = mid + 1;
        else
            high = mid - 1;
    }
    return -1;
}

Example usage

int[] arr = { 2, 3, 4, 10, 40 };
int target = 10;
int result = BinarySearch(arr, target);
Console.WriteLine("Element is present at index: " + result);

Graph Algorithms

These figure out connections between things, like finding the fastest route on a map.

• Depth-First Search (DFS): Goes as far as possible along each path before backtracking.
• Breadth-First Search (BFS): Looks at all the nearby things first before moving to the next level.
• Dijkstra’s Algorithm: Finds the shortest path between two points on a map.

Depth-First Search (DFS)

public void DFS(Dictionary<char, List<char>> graph, char start, HashSet<char> visited)
{
    visited.Add(start);
    Console.Write(start + " ");
    foreach (char neighbor in graph[start])
    {
        if (!visited.Contains(neighbor))
            DFS(graph, neighbor, visited);
    }
}

Example usage

Dictionary<char, List<char>> graph = new Dictionary<char, List<char>>
{
    { 'A', new List<char> { 'B', 'C' } },
    { 'B', new List<char> { 'A', 'D', 'E' } },
    { 'C', new List<char> { 'A', 'F' } },
    { 'D', new List<char> { 'B' } },
    { 'E', new List<char> { 'B', 'F' } },
    { 'F', new List<char> { 'C', 'E' } }
};
HashSet<char> visited = new HashSet<char>();
Console.Write("DFS Traversal: ");
DFS(graph, 'A', visited);

Machine Learning Algorithms

These help computers learn from examples and make decisions, like recognising faces in photos.

• Supervised Learning: Learns from labeled examples, like telling a computer what a cat looks like.
• Unsupervised Learning: Finds patterns in data without being told what to look for, like organising a messy room without instructions.
• Reinforcement Learning: Learns by trying things and getting rewards or punishments, like a dog learning tricks by getting treats or scolded.

Example using Accord.NET for supervised learning (Linear Regression)

using Accord.Statistics.Models.Regression.Linear;

// Sample data
double[] x = { 1, 2, 3 };
double[] y = { 2, 4, 6 };

// Create and fit the model
var ols = new OrdinaryLeastSquares();
SimpleLinearRegression model = ols.Learn(x, y);

// Predict using the model
double x_new = 4;
double y_pred = model.Transform(x_new);
Console.WriteLine("Predicted value for x=4: " + y_pred);

Optimisation Algorithms

These find the best solution to a problem, like figuring out the best route for delivering packages.

• Gradient Descent: Keeps adjusting until it finds the lowest point, like finding the bottom of a valley.
• Genetic Algorithms: Mimics natural selection to find the best solution, like breeding the fittest animals to get even fitter ones.
• Simulated Annealing: Randomly explores different solutions but gradually focuses on the best ones, like cooling down hot metal to make it stronger.

Gradient Descent

public double[] GradientDescent(double[] X, double[] y, double[] theta, double alpha, int numIters)
{
    int m = y.Length;
    for (int iter = 0; iter < numIters; iter++)
    {
        double[] predictions = new double[m];
        for (int i = 0; i < m; i++)
        {
            predictions[i] = theta[0] + theta[1] * X[i];
        }
        double totalError = 0;
        double gradient0 = 0;
        double gradient1 = 0;
        for (int i = 0; i < m; i++)
        {
            double error = predictions[i] - y[i];
            totalError += error;
            gradient0 += error;
            gradient1 += error * X[i];
        }
        theta[0] -= alpha * gradient0 / m;
        theta[1] -= alpha * gradient1 / m;
    }
    return theta;
}

Example usage

double[] X = { 1, 2, 3 };
double[] y = { 2, 4, 6 };
double[] theta = { 0, 0 };
double alpha = 0.1;
int numIters = 1000;
theta = GradientDescent(X, y, theta, alpha, numIters);
Console.WriteLine("Optimised theta: [" + theta[0] + ", " + theta[1] + "]");

Quantum Algorithms

Quantum computers, which work with quantum bits or qubits, can solve certain problems much faster than traditional computers. This could revolutionise fields like cryptography, optimisation, and machine learning.

Advancements in Deep Learning and AI

Deep learning, inspired by the human brain, is getting better at tasks like recognising images and understanding language. As computers get more powerful and data gets bigger, these algorithms will become even smarter and more adaptable.