1What is a searching algorithm?

A searching algorithm is a precise, step-by-step set of instructions a computer follows to find a specific piece of data inside a (possibly huge) dataset — like finding one name in a phone book with a million entries, but doing it in a way a computer can follow exactly, with no "just eyeballing it."

2What is a linear search?

Imagine you're looking for your friend's name in an unsorted stack of index cards. You don't know where it is, and the cards aren't in any order — so your only honest option is to pick up the first card, check it, then the second, then the third, and so on, until you either find the name or run out of cards. That's exactly what a linear search does.

• It starts at the first value in the dataset.
• It checks values one at a time, in order.
• It can be used even if the data is completely unsorted — that's actually its one big advantage over faster searches like binary search, which require sorted data.

Here's the pseudocode from the textbook, worked through step by step. We're searching for target = 11 in data = [5, 2, 8, 1, 9]:

DECLARE data : ARRAY[1:5] OF INTEGER
DECLARE target : INTEGER
DECLARE found : BOOLEAN

data ← [5, 2, 8, 1, 9]
target ← 11
found ← FALSE  // assume not found until proven otherwise

FOR index ← 1 TO 5
   IF data[index] = target THEN
      found ← TRUE
      OUTPUT "Target found"
   ENDIF
NEXT index

IF found = FALSE THEN
   OUTPUT "Target not found"
ENDIF

Notice the shape of this: a flag variable (found) starts as FALSE, and only flips to TRUE if a match is discovered. After the loop finishes, you check the flag to decide what to output. This "flag pattern" shows up constantly in IGCSE pseudocode — get comfortable with it.

1What is a sorting algorithm?

A sorting algorithm is a set of step-by-step instructions that rearranges data into a specific order — usually numerical (smallest to largest) or alphabetical (A to Z).

2What is a bubble sort?

Think of a bubble sort like a line of people standing in a random order of height, and you (the "algorithm") walk down the line comparing each pair of neighbours. If the person on the left is taller than the person on the right, you swap them. You keep walking to the end of the line — that's one full pass. Then you walk the whole line again, and again, until you make a full pass with zero swaps — meaning everyone is finally in order.

The name "bubble sort" comes from the fact that on each pass, the largest unsorted value "bubbles up" to its correct position at the end — a bit like an air bubble rising to the top of water.

Let's trace Pass 1 on the dataset [9, 2, 4, 7, 10, 3, 1] from the textbook, comparing neighbours left to right:

See how 10, the largest number, "bubbled" all the way to the end of the list in just one pass? That always happens — the biggest unsorted value reaches its final position by the end of every pass. That's why, on the next pass, you technically don't even need to re-check the last element again (though you don't have to worry about that detail for the exam).

Here's the full pseudocode, using a swaps flag exactly like the found flag in linear search:

DECLARE nums : ARRAY[1:11] OF INTEGER
nums ← [66, 7, 69, 50, 42, 80, 71, 321, 67, 8, 39]
DECLARE numlength : INTEGER
numlength ← 11
DECLARE swaps : BOOLEAN
swaps ← TRUE

WHILE swaps = TRUE
   swaps ← FALSE
   FOR y ← 1 TO numlength - 1
      IF nums[y] > nums[y + 1] THEN
         DECLARE temp : INTEGER
         temp ← nums[y]
         nums[y] ← nums[y + 1]
         nums[y + 1] ← temp
         swaps ← TRUE  // a swap was made
      ENDIF
   NEXT y
   numlength ← numlength - 1  // last value now sorted, shrink range
ENDWHILE

1What is totalling?

Totalling means keeping a running sum of values as they're entered or read — exactly like a supermarket till adding up the price of items as they're scanned. You start a variable at 0, and every time a new value comes in, you add it on.

Total ← 0
FOR Count ← 1 TO ReceiptLength
   INPUT ItemValue
   Total ← Total + ItemValue
NEXT Count
OUTPUT Total

Notice: Total must start at 0 before the loop. If you forgot to initialise it, the first "add" would be adding onto an undefined value — a classic bug (and a classic mark lost in the exam).

2What is counting?

Counting is when a variable is incremented (or decremented) by a fixed step — usually 1 — every time a loop iterates, to track how many times something has happened. It's different from totalling: totalling adds up the actual values, counting just tallies the number of occurrences.

Incrementing example — counting up to 50:

Count ← 0
DO
   OUTPUT "Pass number", Count
   Count ← Count + 1
UNTIL Count >= 50

Decrementing example — counting down from 50 to 0:

Count ← 50
DO
   OUTPUT "Pass number", Count
   Count ← Count - 1
UNTIL Count <= 0

1Why these three together?

Finding the largest (max), smallest (min), and average (mean) of a list are extremely common tasks — think leaderboard high scores, coldest/hottest temperature of the week, or a class's average test grade. They're grouped together here because in practice you often calculate all three from the same dataset in one go.

Here's the textbook's pseudocode, finding all three from a list of test scores:

Total ← 0
Scores ← [25, 11, 84, 91, 27]

Highest ← max(Scores)
Lowest ← min(Scores)

FOR Count ← 0 TO LENGTH(Scores) - 1
   Total ← Total + Scores[Count]
NEXT Count

Average ← Total / LENGTH(Scores)

OUTPUT "The highest score is:", Highest
OUTPUT "The lowest score is:", Lowest
OUTPUT "The average score is:", Average

For this dataset: Highest = 91, Lowest = 11, and Total = 25+11+84+91+27 = 238, so Average = 238 ÷ 5 = 47.6.

// Manual method — no built-in max() function
Highest ← Scores[0]
FOR Count ← 1 TO LENGTH(Scores) - 1
   IF Scores[Count] > Highest THEN
      Highest ← Scores[Count]
   ENDIF
NEXT Count