Efficiency and Optimisation

Active learning is crucial for understanding algorithm efficiency. By engaging directly with different algorithms, students move beyond theoretical definitions to practical experience. This hands-on approach helps solidify the idea that there's often more than one way to solve a problem, and performance matters.

• Year 7
• Computing
• 3 activities
• 25 min–40 min

Problem-Based Learning

⏱ 30 min·Small Groups

Algorithm Race: Sorting Methods

Students are given two different sorting algorithms (e.g., bubble sort vs. selection sort) to sort a small set of physical cards. They time each method and record the number of swaps, discussing which was faster and why.

Prepare & details

Compare two different algorithms designed to solve the same problem, assessing their efficiency.

Facilitation Tip: For the 'Algorithm Race', ensure students understand the 'Problem-Based Learning' mechanic by encouraging them to define their own criteria for 'best' before the race begins, not just speed.

Setup: Groups at tables with access to research materials

Materials: Problem scenario document, KWL chart or inquiry framework, Resource library, Solution presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management
• Relationship Skills

Problem-Based Learning

⏱ 25 min·Pairs

Code Tracing: Loop Optimisation

Provide students with a simple program containing a nested loop that performs a redundant calculation. Have them trace the execution step-by-step, identify the inefficiency, and then rewrite the code to perform the calculation only once.

Prepare & details

Design an improved version of a given algorithm to make it more efficient.

Facilitation Tip: When students are tracing code in 'Code Tracing', guide them using the 'Decision Matrix' approach by prompting them to create a simple matrix comparing the original loop's steps against the refactored loop's steps.

Setup: Groups at tables with access to research materials

Materials: Problem scenario document, KWL chart or inquiry framework, Resource library, Solution presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management
• Relationship Skills

Problem-Based Learning

⏱ 40 min·Small Groups

Algorithm Design Challenge

Present a simple problem, like finding the shortest path on a small grid. Students work in groups to design two different algorithms to solve it, then present their approaches and justify which they believe is more efficient.

Prepare & details

Justify the trade-offs between algorithm complexity and execution speed.

Facilitation Tip: During the 'Algorithm Design Challenge', facilitate 'Problem-Based Learning' by allowing groups to present multiple valid solutions and justify their design choices, embracing ambiguity.

Setup: Groups at tables with access to research materials

Materials: Problem scenario document, KWL chart or inquiry framework, Resource library, Solution presentation template

• Analyze
• Evaluate
• Create
• Decision-Making
• Self-Management
• Relationship Skills

Teaching This Topic

Approach this topic by framing efficiency as a key characteristic of a 'good' algorithm, alongside correctness. Avoid simply presenting formulas; instead, use comparative activities to build intuition. Research shows that concrete examples and opportunities for student-led comparison are most effective for developing this understanding.

What to Expect

Students will be able to articulate why comparing algorithms based on performance, not just correctness, is important. They will demonstrate an understanding that input size significantly impacts an algorithm's efficiency and be able to identify potential areas for optimisation in simple code.

Watch Out for These Misconceptions

Common Misconception

During the 'Algorithm Race', students may stop at the first sorting algorithm that correctly orders the data. Help them see that correctness is only one part of a good algorithm by highlighting the performance differences observed during the race.

What to Teach Instead

Redirect students to compare the number of swaps or comparisons each algorithm made during the 'Algorithm Race'. Use this data to discuss why one algorithm might be preferred over another, even if both yield the correct result.

Common Misconception

During 'Code Tracing: Loop Optimisation', students might believe that simplifying code for efficiency always makes it harder to read. Demonstrate how removing redundant calculations in the nested loop can actually improve clarity.

What to Teach Instead

After students refactor the code in 'Code Tracing', have them explain in their own words why the optimised version is clearer. Ask them to compare the 'before' and 'after' code side-by-side, focusing on the reduction of repeated steps.

Assessment Ideas

Discussion Prompt

After the 'Algorithm Race', facilitate a class discussion comparing the performance of the sorting algorithms. Ask students to justify which algorithm they would choose for different data sizes and why.

Quick Check

During 'Code Tracing: Loop Optimisation', observe students' ability to identify the redundant calculation and successfully refactor the nested loop. Check their refactored code for correctness and efficiency gains.

Peer Assessment

In the 'Algorithm Design Challenge', have groups present their shortest path solutions. Allow other groups to ask clarifying questions and provide constructive feedback on the efficiency and clarity of the presented algorithm.

Extensions & Scaffolding

• Challenge: For students who grasp the concepts quickly, ask them to research Big O notation and relate it to the sorting algorithms they raced.
• Scaffolding: For students who struggle, provide pre-filled comparison tables for the 'Algorithm Race' or a partially refactored code snippet for 'Code Tracing'.
• Deeper Exploration: Have students explore other sorting algorithms like merge sort or quicksort and analyze their efficiency compared to bubble or selection sort.