⚡ Quick Summary: Algorithms at a Glance
- Bubble Sort: Compares adjacent elements and swaps them if in the wrong order. O(n²) time complexity. Simple but inefficient for large data.
- Insertion Sort: Builds a sorted portion of the array one element at a time, inserting each new element in the correct position.
- Linear Search: Checks every element one by one from the start. Works on unsorted data. O(n) time complexity.
- Binary Search: Divides sorted data in half repeatedly to locate a target. O(log n) time complexity — much faster but requires sorted data.
In This Guide:
1. Bubble Sort Pseudocode
Bubble Sort repeatedly passes through the list, comparing adjacent elements and swapping them if they are in the wrong order. Each pass "bubbles" the largest unsorted element to its correct position at the end.
// Array A[1:n] is declared and populated before this DECLARE i, j, Temp : INTEGER DECLARE n : INTEGER n ← 5 FOR i ← 1 TO n - 1 FOR j ← 1 TO n - i IF A[j] > A[j + 1] THEN // Swap using a temporary variable Temp ← A[j] A[j] ← A[j + 1] A[j + 1] ← Temp ENDIF NEXT j NEXT i
2. Insertion Sort Pseudocode
Insertion Sort builds the sorted array one item at a time. It picks each element and inserts it into the correct position relative to the already-sorted elements to its left.
DECLARE i, j, Key : INTEGER FOR i ← 2 TO n Key ← A[i] j ← i - 1 WHILE j >= 1 AND A[j] > Key A[j + 1] ← A[j] j ← j - 1 ENDWHILE A[j + 1] ← Key NEXT i
3. Linear Search Pseudocode
Linear Search (also called Sequential Search) checks each element one by one from the beginning until the target is found or the end is reached. It works on both sorted and unsorted arrays.
DECLARE Target, i : INTEGER DECLARE Found : BOOLEAN Found ← FALSE OUTPUT "Enter the value to search for:" INPUT Target FOR i ← 1 TO n IF A[i] = Target THEN Found ← TRUE OUTPUT "Found at index: ", i ENDIF NEXT i IF Found = FALSE THEN OUTPUT "Value not found." ENDIF
4. Binary Search Pseudocode
Binary Search is much more efficient than linear search but requires the array to be sorted first. It works by repeatedly halving the search range, comparing the target to the middle element.
DECLARE Target, Low, High, Mid : INTEGER DECLARE Found : BOOLEAN Low ← 1 High ← n Found ← FALSE OUTPUT "Enter value to find:" INPUT Target WHILE Low <= High AND Found = FALSE Mid ← (Low + High) DIV 2 IF A[Mid] = Target THEN Found ← TRUE OUTPUT "Found at index: ", Mid ELSE IF A[Mid] < Target THEN Low ← Mid + 1 ELSE High ← Mid - 1 ENDIF ENDIF ENDWHILE IF Found = FALSE THEN OUTPUT "Value not found." ENDIF
Algorithm Comparison Table
| Algorithm | Time Complexity | Needs Sorted Data? | Best For |
|---|---|---|---|
| Bubble Sort | O(n²) | No | Small datasets, teaching |
| Insertion Sort | O(n²) | No | Nearly sorted data |
| Linear Search | O(n) | No | Small/unsorted data |
| Binary Search | O(log n) | Yes — must be sorted | Large sorted datasets |
Interactive Exam Practice
Scenario: Write a Bubble Sort algorithm that sorts an array of 6 names (strings) into alphabetical order and then outputs them.
Hover to reveal the answer. Click Run Code to test it instantly!
DECLARE Names[1:6] : STRING DECLARE i, j : INTEGER DECLARE Temp : STRING Names[1] ← "Zara" Names[2] ← "Alice" Names[3] ← "Mike" Names[4] ← "Ben" Names[5] ← "Quinn" Names[6] ← "Emma" FOR i ← 1 TO 5 FOR j ← 1 TO 6 - i IF Names[j] > Names[j + 1] THEN Temp ← Names[j] Names[j] ← Names[j + 1] Names[j + 1] ← Temp ENDIF NEXT j NEXT i FOR i ← 1 TO 6 OUTPUT Names[i] NEXT i