Bubble sort is one of the simplest sorting methods. It works by comparing two numbers next to each other and swapping them if they are in the wrong order. This process repeats until the whole array is sorted.

It is not the fastest way to sort data, but it is easy to understand and good for learning.

How it works

1. Start from the first element
2. Compare it with the next one
3. Swap them if needed
4. Move one step forward
5. Repeat until the end of the array
6. Do the same process again until no swaps are needed

PHP Example

<?php
function bubbleSort($numbers) {
    $totalCount = count($numbers);

    for ($pass = 0; $pass < $totalCount; $pass++) {
        for ($index = 0; $index < $totalCount - $pass - 1; $index++) { 
if ($numbers[$index] > $numbers[$index + 1]) {
                // swap
                $temporaryValue = $numbers[$index];
                $numbers[$index] = $numbers[$index + 1];
                $numbers[$index + 1] = $temporaryValue;
            }
        }
    }

    return $numbers;
}

$numbers = [5, 3, 8, 4, 2];
$sorted = bubbleSort($numbers);

print_r($sorted);

Output

Array
(
    [0] => 2
    [1] => 3
    [2] => 4
    [3] => 5
    [4] => 8
)

When to use it

Bubble sort is fine for small lists or for learning. It is not good for large data because it is slow compared to other methods.

Summary

Bubble sort is simple and easy to code in PHP. It helps you understand how sorting works, even if you will not use it in real projects often.

Binary search is a super efficient way to find an item in a sorted list. Instead of checking every single item one by one, it splits the list in half repeatedly until it finds what you are looking for.

Think of it like looking up a word in a dictionary: you open it to the middle, decide if your word is earlier or later, and then repeat the process with the correct half.

How it works:

1. Find the middle element of the array.

2. If the middle element matches your target, you’re done!

3. If the target is smaller, repeat the process on the left half.

4. If the target is larger, repeat the process on the right half.

function binarySearch(array $array, int $target): ?int {
    $low = 0;
    $high = count($array) - 1;

    while ($low <= $high) {
        // Use the middle index
        $mid = $low + intdiv($high - $low, 2);

        if ($array[$mid] === $target) {
            return $mid;
        }

        if ($array[$mid] < $target) {
            $low = $mid + 1;
        } else {
            $high = $mid - 1;
        }
    }

    return null;
}

// Example usage:
$data = [10, 22, 35, 47, 50, 68, 75];
$result = binarySearch($data, 47);

echo ($result !== null) ? "Found at index: $result" : "Value not found.";

Linear search is one of the easiest search algorithms to understand. It does exactly what the name suggests: it looks at items one by one until it finds what it’s looking for or reaches the end of the list.

There’s no trick to it. If you have an array, linear search starts at the first element, compares it with the value you want, and keeps going until it either finds a match or runs out of elements.

How it works:

1. Start from the first item in the array

2. Compare it with the target value

3. If it matches, stop

4. If not, move to the next item

5. Repeat until the array ends

When should you use it?

Linear search is fine when:

The array is small

The data is not sorted

You want something quick and easy to write

It’s not the fastest option for large datasets, since it may have to check every item. But for simple tasks, it gets the job done without extra complexity.

A bit of history

Linear search is basically as old as computing itself. Early computers didn’t have fancy data structures or fast memory access, so checking data one piece at a time was the normal approach. Even before computers, people used the same idea—think of flipping through a phone book page by page or checking names on a handwritten list.

Because of that, linear search is often the first algorithm taught in computer science. It’s not impressive or clever, but it mirrors how humans naturally search, which is why it has stuck around for so long.

Simple, clear, and still useful today.

I’m starting a short series of posts about algorithms and basic computer science. The goal is to explain ideas clearly, without unnecessary jargon, and to understand them better by writing them out. Mostly this is about slowing down, breaking things apart, and seeing how they actually work.