Stack Concept and LIFO Principle in DSA Python - Build from Scratch

Stack Concept and LIFO Principle

📖 Scenario: Imagine you are organizing a stack of books on a table. You can only add or remove the top book. This is how a stack works in programming, following the Last In, First Out (LIFO) principle.

🎯 Goal: You will create a stack using a list, add books to it, remove the top book, and then show the final stack order.

📋 What You'll Learn

Create a list called stack with initial books

Add a new book to the top of the stack

Remove the top book from the stack

Print the final stack showing the order of books from bottom to top

💡 Why This Matters

🌍 Real World

Stacks are used in real life when you pile plates or books where you can only take the top one first.

💼 Career

Understanding stacks helps in programming tasks like undo features, expression evaluation, and managing function calls.

1

Create the initial stack

Create a list called stack with these exact books in order: 'Book1', 'Book2', 'Book3'

DSA Python

# Create the initial stack list with 'Book1', 'Book2', 'Book3'
# Your code here

Hint

Use square brackets [] to create a list and separate items with commas.

2

Add a new book to the stack

Add the book 'Book4' to the top of the stack using the append method

DSA Python

stack = ['Book1', 'Book2', 'Book3']
# Add 'Book4' to the top of the stack
# Your code here

Hint

Use stack.append('Book4') to add the new book on top.

3

Remove the top book from the stack

Remove the top book from the stack using the pop method and store it in a variable called removed_book

DSA Python

stack = ['Book1', 'Book2', 'Book3']
stack.append('Book4')
# Remove the top book and save it in 'removed_book'
# Your code here

Hint

Use removed_book = stack.pop() to remove the last added book.

4

Print the final stack

Print the stack list to show the books remaining from bottom to top

DSA Python

stack = ['Book1', 'Book2', 'Book3']
stack.append('Book4')
removed_book = stack.pop()
# Print the final stack
# Your code here

Hint

Use print(stack) to display the current stack.

Practice

1. What does the LIFO principle mean in the context of a stack?

easy

A. Last In, First Out - the first item added is the first to be removed

B. Last In, First Out - the last item added is the first to be removed

C. First In, First Out - the first item added is the first to be removed

D. First In, Last Out - the first item added is the last to be removed

Solution

1. Step 1: Understand LIFO meaning

   LIFO means the last element added to the stack is the first one to be removed.

2. Step 2: Match with options

   Last In, First Out - the last item added is the first to be removed correctly describes this behavior as "Last In, First Out".

3. Final Answer:

   Last In, First Out - the last item added is the first to be removed -> Option B

4. Quick Check:

   LIFO = Last In, First Out [OK]

Hint: Remember stack removes newest item first [OK]

Common Mistakes:

• Confusing LIFO with FIFO
• Thinking first added is removed first
• Mixing order of insertion and removal

2. Which of the following is the correct way to push an element '5' onto a stack named stack in Python?

easy

A. stack.append(5)

B. stack.add(5)

C. stack.push(5)

D. stack.insert(5)

Solution

1. Step 1: Recall Python list methods for stack

   Python uses list's append() method to add elements to the top of the stack.

2. Step 2: Check options for correct method

   Only stack.append(5) uses append(5), which is correct for pushing onto a stack.

3. Final Answer:

   stack.append(5) -> Option A

4. Quick Check:

   Push in Python stack = append() [OK]

Hint: Use append() to push in Python stack [OK]

Common Mistakes:

• Using push() which is not a Python list method
• Using add() which is for sets
• Using insert() which inserts at specific index

3. What will be the output of the following Python code?

stack = []
stack.append(10)
stack.append(20)
stack.append(30)
print(stack.pop())
print(stack.pop())
print(stack)

medium

A. 30
10
[20]

B. 10
20
[30]

C. 20
30
[10]

D. 30
20
[10]

Solution

1. Step 1: Trace stack after each append

   After append(10): [10], append(20): [10, 20], append(30): [10, 20, 30]

2. Step 2: Trace pop operations

   pop() removes last element: first pop() returns 30, second pop() returns 20, stack left is [10]

3. Final Answer:

   30 20 [10] -> Option D

4. Quick Check:

   Stack pops last in first out [OK]

Hint: Pop removes last pushed element first [OK]

Common Mistakes:

• Thinking pop removes first element
• Confusing order of popped elements
• Not updating stack after pop

4. Identify the error in the following code that implements a stack using a Python list:

stack = []
stack.push(1)
stack.push(2)
print(stack.pop())

medium

A. Using push() method which does not exist for Python lists

B. Using pop() method incorrectly

C. Stack should be initialized as a tuple, not list

D. Missing import statement for stack

Solution

1. Step 1: Check methods used on list

   Python lists do not have a push() method; append() is used to add elements.

2. Step 2: Verify pop() usage

   pop() is valid for lists and correctly used here.

3. Final Answer:

   Using push() method which does not exist for Python lists -> Option A

4. Quick Check:

   Python list push() does not exist [OK]

Hint: Use append(), not push(), to add in Python list [OK]

Common Mistakes:

• Assuming push() is valid for Python lists
• Thinking pop() needs arguments
• Confusing list with stack module

5. Given a stack implemented as a Python list, which sequence of operations will reverse the order of elements in the stack?
Assume initial stack is [1, 2, 3] where 3 is the top.
Choose the correct sequence:

hard

A. Append elements to the stack again without popping

B. Use pop() repeatedly and append to the same stack without extra storage

C. Pop all elements into a new stack

D. Sort the stack list in ascending order

Solution

1. Step 1: Understand reversing stack by popping

   Pop elements from original stack and push them into a new stack reverses order.

2. Step 2: Confirm other options

   Appending without popping or sorting does not reverse stack order correctly.

3. Final Answer:

   Pop all elements into a new stack -> Option C

4. Quick Check:

   Two stacks pop/push reverses order [OK]

Hint: Use two stacks to reverse order [OK]

Common Mistakes:

• Trying to reverse by sorting
• Appending without popping
• Using one stack without extra storage