Homeschool Guide: These lesson plans are a guide for parents. Content may contain errors — always cross-reference with official exam board specifications.

efficiency of algorithms

FoundationHigherAll Boards

4 detailed 50-minute lessons with teaching scripts, worked examples, parent guides, and assessment criteria.

Fastmail

Lesson Overview

Total Lessons: 4
Tier: Foundation and Higher
Duration: 50 minutes per lesson (200 minutes total)
Exam Boards: AQA, Edexcel, OCR, Eduqas, CCEA

Learning Objectives

Prerequisites

Materials & Equipment

Lesson 1: Introduction: efficiency of algorithms

Duration: 50 minutes

Starter Activity (5 minutes)

Quick Recall

Write down everything you already know about efficiency of algorithms. Then check against the key terms: Key Principle, Crucial Point, Exam Focus. Use a mini-whiteboard or paper.

Main Content (35 minutes)

Parent/Teacher Guide:
Before lesson: Read the script below. Pre-teach key vocab: Key Principle, Crucial Point, Exam Focus.
If stuck: Re-read the revision notes (link above), then break the content into smaller steps.
Extension: See the Stretch & Challenge ideas in Lesson 4.
Teaching Script (35 mins):
Mins 0-5 - Hook: "Today: efficiency of algorithms. By the end you will be able to answer exam questions on it unaided. It connects to the rest of Computer Science because the ideas here recur across the spec."
Mins 5-20 - Direct Instruction: Work through the core ideas below one at a time; after each, ask your student to explain it back in their own words.
Mins 20-30 - Guided Practice: Model the worked example together, then let your student attempt the first practice question with guidance.
Mins 30-35 - Independent Practice: 2-3 practice questions from Lesson 3 below, with immediate feedback.
First Look

Start with the revision notes summary, then attempt: What does time complexity measure?

Plenary (5 minutes)

Check Out

Your student states one thing they learned and one question they still have about efficiency of algorithms.

Lesson 2: Core Concepts: efficiency of algorithms

Duration: 50 minutes

Starter Activity (5 minutes)

Review Previous Lesson

Quick recap: write 3 key points from Lesson 1 on efficiency of algorithms. Check them against the notes below.

Main Content (35 minutes)

Definition: Algorithm efficiency measures how much time and/or memory an algorithm uses to solve a problem. A more efficient algorithm uses fewer resources (time and space) to produce the same result.
Key Principle: When two algorithms solve the same problem, the more efficient one will complete in fewer steps, especially as the input size increases.
Crucial Point: Some algorithms that seem fast for small inputs become extremely slow for large inputs. The rate at which time increases matters more than the time for a single small input.
Exam Focus: At GCSE level, you need to understand that some algorithms are more efficient than others and explain WHY. You should be able to compare linear search vs binary search, and bubble sort vs merge sort, in terms of efficiency.
GCSE Computer Science Exam Tips: When comparing algorithm efficiency, always refer to Big O notation and explain how the number of operations grows with input size. Use concrete examples (e.g. n=100, n=1000) to illustrate differences. Remember that time complexity is about growth rate, not actual speed. Mention that Big O ignores constants and lower-order terms. If asked to compare algorithms, consider both time AND space complexity where relevant.
TermMeaningExample
1010 checks4 checks
100100 checks7 checks
1,0001,000 checks10 checks
1,000,0001,000,000 checks20 checks
O(1)Constant timeTime stays the same regardless of input size
O(log n)LogarithmicTime increases very slowly - halves the problem each step
O(n)LinearTime increases proportionally with input size
O(n log n)LinearithmicTime increases slightly more than linearly

Practice (10 minutes)

Q: What does time complexity measure?

Answer: Time complexity measures how the running time of an algorithm grows as the input size increases. It describes the relationship between input size and number of operations.

Plenary (5 minutes)

Explain Back

Your student teaches the key points back to you without looking. Fill any gaps immediately.

Lesson 3: Application: efficiency of algorithms

Duration: 50 minutes

Starter Activity (5 minutes)

Quick Recall

Recall the key terms: Key Principle, Crucial Point, Exam Focus. Define each in one sentence.

Main Content (35 minutes)

Parent/Teacher Guide: Let your student attempt each question alone first, then compare with the model answer. Award method marks for correct working even if the final answer is wrong.

Q1: What does time complexity measure?

Answer: Time complexity measures how the running time of an algorithm grows as the input size increases. It describes the relationship between input size and number of operations.

Q2: An algorithm has O(n) time complexity. If it takes 5 seconds to process 1000 items, approximately how long would it take to process 5000 items?

Answer: Approximately 25 seconds. O(n) means time is proportional to input size. 5000 is 5 times 1000, so 5 × 5 = 25 seconds.

Q3: Explain why binary search is more efficient than linear search for large datasets.

Answer: Binary search halves the search space each step, so it needs at most log₂(n) comparisons. Linear search checks every item, needing up to n comparisons. For large n, log₂(n) is vastly smaller than n.

Q4: Give an example of a situation where using a less efficient algorithm might be acceptable.

Answer: When the dataset is very small (e.g. sorting 10 items), the difference between efficient and inefficient algorithms is negligible. Also, when the algorithm only runs once and speed is not critical.

Q5: A bubble sort on 100 items takes up to 10,000 comparisons. How many comparisons would it take for 1000 items?

Answer: Up to 1,000,000 comparisons. Bubble sort is O(n²), so for 1000 items: 1000 × 1000 = 1,000,000.

Plenary (5 minutes)

Error Review

Review any questions answered incorrectly. Identify whether the error was knowledge, method, or reading the question.

Lesson 4: Exam Practice: efficiency of algorithms

Duration: 50 minutes

Starter Activity (5 minutes)

Command Words

Review what these command words require: state (one point), describe (say what happens), explain (say why), compare (both sides), evaluate (judgement).

Main Content (35 minutes)

Extended Answer

Extended question: Full-Mark Response Two algorithms solve the same problem. Algorithm A has time complexity O(n²) and Algorithm B has O(n log n). Explain which algorithm is more efficient for large datasets and why. [4 marks] <div class="

Algorithm B (O(n log n)) is more efficient for large datasets. As n increases, n² grows much faster than n log n. For example, with n = 1000: Algorithm A performs roughly 1,000,000 operations while Algorithm B performs roughly 10,000 operations. Big O notation shows that Algorithm B scales better because its growth rate is lower, meaning it will be significantly faster for large inputs. However, for very small datasets Algorithm A might be comparable due to lower constant overhead.

Exam Tips: You don't need to calculate exact Big O values - just understand the concept | Be able to explain that binary search is more efficient than linear search because it halves the search space | Be able to explain that merge sort is more efficient than bubble sort for large datasets | Use the terms "time complexity" and "proportional to" in your answers | If asked to compare algorithms, always mention how performance changes as input size grows | Remember: O(n²) algorithms become impractical for large datasets
Common Errors: ✗ Thinking a faster algorithm is always better regardless of memory usage ✓ Efficiency considers both time and space; a faster algorithm may use significantly more memory, which could be unsuitable for constrained systems. ✗ Confusing time complexity with actual running time ✓ Time complexity describes how the number of operations grows with input size (Big O), not the actual clock time a program takes to run. ✗ Believing O(n) is always worse than O(log n) for all inputs ✓ O(log n) scales better for large inputs, but for very small datasets the constant overhead of O(log n) algorithms may make O(n) faster in practice. ✗ Thinking Big O notation measures exact step counts ✓ Big O notation desc
Stretch & Challenge (Grade 8-9):
  • Synoptic links: explain how efficiency of algorithms connects to another Computer Science topic you have studied
  • Real-world: research one real-world use or example of efficiency of algorithms
  • Critical: "What are the limitations of the models used in efficiency of algorithms?"

Plenary (5 minutes)

Assessment Criteria
  • Got it: Confident explanation + correct worked examples
  • Getting there: Main points OK, needs support with detail
  • Not yet: Confused on key concepts - re-run Lesson 2

Homework & Consolidation

Recommended Resources

🎓 Smart Lesson (Guided)