Stacks and Queues: LIFO & FIFO

Active learning works because stacks and queues are intuitive in physical form yet abstract in concept. When students physically act out LIFO and FIFO, the rules stick in ways a lecture never could. The mismatch between how we naturally think and how these structures behave creates memorable cognitive dissonance that leads to deeper understanding.

• 10th Grade
• Computer Science
• 4 activities
• 20 min–45 min

Learning Objectives

1. Compare the operational principles of stacks (LIFO) and queues (FIFO) by identifying their distinct ordering mechanisms.
2. Analyze real-world scenarios to explain why a stack or a queue is the appropriate data structure for managing sequential operations.
3. Construct a basic program that simulates a task scheduler using a queue data structure.
4. Identify and describe at least three distinct applications of stacks in software development.
5. Evaluate the efficiency of using stacks and queues for specific problem-solving contexts.

Simulation Game

⏱ 25 min·Whole Class

Simulation Game: Human Stack and Queue

Use two groups of students as physical stacks and queues. The teacher calls out operations (push, pop, enqueue, dequeue) while students physically move in or out of a line. After the simulation, students sketch the state of both structures at several checkpoints and explain what invariant each structure maintains.

Prepare & details

Differentiate between the LIFO and FIFO principles.

Facilitation Tip: During the Human Stack and Queue simulation, clearly mark the front and back of the line with tape or signs to avoid ambiguity in direction.

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

Think-Pair-Share

⏱ 20 min·Pairs

Think-Pair-Share: Spot the Structure

Give pairs a list of 10 real-world systems (browser back button, print queue, function call log, ticket line, undo history). Each pair classifies each system as stack-based, queue-based, or neither, and writes one sentence justifying each choice. Pairs then compare with another pair and resolve disagreements as a group of four.

Prepare & details

Analyze real-world applications where stacks are essential.

Facilitation Tip: For Think-Pair-Share, provide a timer so pairs have 2 minutes to discuss before sharing with the class to keep energy high.

Setup: Standard classroom seating; students turn to a neighbor

Materials: Discussion prompt (projected or printed), Optional: recording sheet for pairs

• Understand
• Apply
• Analyze
• Self-Awareness
• Relationship Skills

Role Play

⏱ 45 min·Small Groups

Collaborative Coding: Task Manager Queue

Small groups implement a simple task scheduler using a queue data structure. They are given a starter file with incomplete enqueue and dequeue methods, a list of test tasks, and instructions to process tasks in arrival order. Groups compare their output logs and troubleshoot any ordering errors together.

Prepare & details

Construct a simple program utilizing a queue for task management.

Facilitation Tip: In the Collaborative Coding activity, assign specific roles like Task Manager and Queue Monitor to ensure every student participates.

Setup: Open space or rearranged desks for scenario staging

Materials: Character cards with backstory and goals, Scenario briefing sheet

• Apply
• Analyze
• Evaluate
• Social Awareness
• Self-Awareness

Gallery Walk

⏱ 40 min·Small Groups

Gallery Walk: Stack Applications Posters

Each group creates a poster for a different stack application (recursion call stack, browser history, expression parsing, undo system), explaining how LIFO behavior makes that application function correctly. Groups rotate and add one insight and one question to each poster before a class debrief.

Prepare & details

Differentiate between the LIFO and FIFO principles.

Facilitation Tip: During the Gallery Walk, ask students to add sticky notes with questions to each poster to spark peer discussion.

Setup: Wall space or tables arranged around room perimeter

Materials: Large paper/poster boards, Markers, Sticky notes for feedback

• Understand
• Apply
• Analyze
• Create
• Relationship Skills
• Social Awareness

Teaching This Topic

Start with physical simulations because bodies in motion make abstract rules visible. Avoid introducing code too early; let students internalize behavior first. Use real-world analogs they already know, like call stacks in everyday apps, but link them explicitly to the structures. Research shows that students grasp these concepts faster when they see the same pattern in multiple contexts, so rotate examples across activities.

What to Expect

Students will confidently distinguish stacks from queues by their access rules and explain real-world uses with examples. They will trace operations step-by-step without confusion between push/pop and enqueue/dequeue. Misconceptions about storage details will fade as they focus on behavior instead of implementation.

Watch Out for These Misconceptions

Common Misconception

During the Simulation activity, watch for students who confuse the terms 'first' and 'last' by pointing to the wrong end of the line.

What to Teach Instead

Pause the simulation when confusion arises and ask students to physically push an object onto their stack or step into the queue, then verbally state who is first and who is last before continuing.

Common Misconception

During the Think-Pair-Share activity, listen for students who claim stacks and queues are just different types of lists because they look similar in code.

What to Teach Instead

Use the posters from the Gallery Walk to point out that the difference is in the access rules, not the storage, and ask students to trace a sequence of operations on each structure to see the behavior difference.

Assessment Ideas

Exit Ticket

After the Human Stack and Queue simulation, provide two real-world scenarios: a printer queue and a browser back button. Ask students to identify which uses a queue and which uses a stack, and explain their reasoning in one sentence.

Quick Check

During the Collaborative Coding activity, ask students to write the final state of the task queue after a series of enqueue and dequeue operations on the whiteboard before moving to the next step.

Discussion Prompt

After the Gallery Walk, facilitate a class discussion where students debate whether a call stack or a task queue is more critical for a web browser, justifying their choice with examples from the posters.

Extensions & Scaffolding

• Challenge: Ask students to design a hybrid structure that uses both stack and queue behaviors for a specific task, such as a browser with both back (stack) and tab order (queue).
• Scaffolding: Provide a partially completed flowchart for the Queue Task Manager activity with missing steps for students to fill in.
• Deeper exploration: Have students research how operating systems use both stacks and queues in process management and present their findings to the class.

Key Vocabulary

Stack	An abstract data type that follows the Last-In, First-Out (LIFO) principle. Items are added (pushed) and removed (popped) from the same end, often called the 'top'.
Queue	An abstract data type that follows the First-In, First-Out (FIFO) principle. Items are added (enqueued) at one end (the 'rear') and removed (dequeued) from the other end (the 'front').
LIFO	Acronym for Last-In, First-Out. The most recently added item to a data structure is the first one to be removed.
FIFO	Acronym for First-In, First-Out. The first item added to a data structure is the first one to be removed.
Push	The operation of adding an element to a stack.
Pop	The operation of removing the top element from a stack.
Enqueue	The operation of adding an element to the rear of a queue.
Dequeue	The operation of removing an element from the front of a queue.