Introduction to Algorithms and Problem Solving

Active learning helps students grasp the speed and memory trade-offs in algorithms because concrete experiences make abstract comparisons visible. When they act out sorting or race through search steps, the difference between O(n) and O(n log n) stops being just theory and becomes something they can feel in their body and timing. This kinesthetic and collaborative approach bridges the gap between mathematical notation and practical software engineering decisions.

• Grade 11
• Computer Science
• 3 activities
• 25 min–40 min

Learning Objectives

1. Define an algorithm and identify its key characteristics, including input, output, finiteness, definiteness, and effectiveness.
2. Compare and contrast the representation of algorithms using pseudocode and flowcharts, analyzing the impact on clarity and implementation.
3. Design a step-by-step algorithm to solve a common daily task, such as making a sandwich or navigating a simple maze.
4. Justify each step in a constructed algorithm, explaining its purpose and contribution to the overall solution.

Simulation Game

⏱ 40 min·Whole Class

Simulation Game: Human Sorting Network

Clear a space in the classroom and have students represent elements in an unsorted list. Assign each student a random number and have them move through a 'sorting network' taped on the floor, comparing values at each node to physically demonstrate bubble sort versus quicksort logic.

Prepare & details

Differentiate between an algorithm and a program.

Facilitation Tip: During the Human Sorting Network, stand at the side and time runs to make the linear versus logarithmic difference obvious to the whole class.

Setup: Flexible space for group stations

Materials: Role cards with goals/resources, Game currency or tokens, Round tracker

• Apply
• Analyze
• Evaluate
• Create
• Social Awareness
• Decision-Making

Inquiry Circle

⏱ 25 min·Small Groups

Inquiry Circle: The Great Search Race

Provide small groups with identical sets of 100 sealed envelopes containing numbers. One group uses linear search while another uses binary search (on a pre-sorted set) to find a specific value, recording the number of 'probes' or checks required to find the target.

Prepare & details

Analyze how different representations of an algorithm impact its clarity and implementation.

Facilitation Tip: For The Great Search Race, assign roles so every student participates in timing and recording results on a shared chart.

Setup: Groups at tables with access to source materials

Materials: Source material collection, Inquiry cycle worksheet, Question generation protocol, Findings presentation template

• Analyze
• Evaluate
• Create
• Self-Management
• Self-Awareness

Formal Debate

⏱ 30 min·Small Groups

Formal Debate: Merge vs. Quick

Assign teams to defend either Mergesort or Quicksort based on specific constraints like memory limits or nearly-sorted data. Students must argue why their assigned algorithm is the superior choice for a given real-world scenario, such as sorting a massive database on a low-power device.

Prepare & details

Construct an algorithm to solve a common daily task, justifying each step.

Facilitation Tip: In the Merge vs. Quick debate, give teams exactly three minutes to prepare arguments using the same data set so the comparison stays fair.

Setup: Two teams facing each other, audience seating for the rest

Materials: Debate proposition card, Research brief for each side, Judging rubric for audience, Timer

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

Teaching This Topic

Teaching this topic works best when you treat algorithms as tools, not just code. Start with physical models so students feel the difference in steps before they see the math. Avoid rushing to the formula; instead, let students discover the inefficiency of linear search on a large list through their own race results. Research shows that students who build the intuition first retain the complexity trade-offs longer than those who memorize Big O notation without context.

What to Expect

By the end of these activities, students should confidently explain why some algorithms scale better than others and choose appropriate tools for small versus large data sets. They should also be able to sketch or describe a simple algorithm in pseudocode or a flowchart without confusing steps or leaving gaps. Most importantly, they should begin to ask questions about efficiency before they start coding.

Watch Out for These Misconceptions

Common Misconception

During Human Sorting Network, watch for students assuming faster computers mean sorting will always feel instant even with inefficient networks.

What to Teach Instead

Pause the activity after each round and ask students to estimate how many more steps the network will need if the list doubles in size. Use their timing data to show that doubling the list quadruples the steps in bubble sort but only adds a few in quicksort.

Common Misconception

During The Great Search Race, watch for students trying to use binary search on an unsorted list of cards.

What to Teach Instead

Hand a shuffled deck to a team and ask them to perform their planned binary search. When they fail to find the target, have them sort the deck first and repeat the search to reveal why the initial sort is non-negotiable.

Assessment Ideas

Quick Check

After Human Sorting Network, present students with a list of five names and ask them to write the exact sequence of swaps their network would perform if it used bubble sort. Collect and check for correct step order and swap logic.

Discussion Prompt

During the Merge vs. Quick debate, ask teams to draw a flowchart side by side on the board for the same 10-item list, then facilitate a vote on which representation better captures the algorithm’s memory use.

Exit Ticket

After The Great Search Race, ask students to write one advantage of mergesort over quicksort based on the timing data they collected, and give one example of a real-world data set where mergesort’s stability matters.

Extensions & Scaffolding

• Challenge: Ask students to design a hybrid sort that switches from bubble sort to quicksort after a threshold of 50 items. Have them test it on a 1,000-item list and compare against pure bubble sort.
• Scaffolding: Provide pre-labeled index cards for the Human Sorting Network so students focus on the flow rather than labeling.
• Deeper exploration: Invite students to research radix sort and present how it compares to quicksort in memory usage and speed for phone number sorting.

Key Vocabulary

Algorithm	A set of well-defined, step-by-step instructions or rules designed to perform a specific task or solve a particular problem.
Pseudocode	An informal, high-level description of the operating principle of a computer program or other algorithm, using conventions that resemble natural language.
Flowchart	A diagram that represents a workflow or process, showing the steps as boxes of various shapes, and their order by connecting the boxes with arrows.
Input	The data or information that an algorithm receives to process.
Output	The result or solution produced by an algorithm after processing the input.