LIFO data structure.

Last In First Out.

Push.

Push on full stack.

Remove top.

Op between operands.

Op after operands.

Track operators.

Pop empty stack.

+xy.

• Linear: Sequential (stack).
• Others: Hierarchical (tree/graph).
• Ex: List vs binary tree.
• Stack: LIFO linear.

• Undo/redo in editors.
• Browser back button.
• Parentheses matching.
• Ex: String reverse.

• Add to top (append).
• Overflow if full.
• Ex: opPush(stack, elem).
• LIFO insertion.

• Remove top (pop).
• Underflow if empty.
• Ex: opPop(stack) returns top.
• LIFO deletion.

• Push: list.append().
• Pop: list.pop().
• No top var needed.
• Dynamic size.

• Algo 3.1 steps.
• Push ops/parens.
• Ex: (x+y) → xy+.
• Prec rules.

• Push operands.
• Pop for op, push result.
• Ex: 78 2* + → 11.
• Single traversal.

• Check len()==0.
• Avoid underflow.
• Ex: Before pop.
• Returns True/False.

• Peek without remove.
• stack[-1].
• Ex: Read top glass.
• If empty: None.

• LIFO linear DS.
• Top insert/delete.
• Ex: Plates (Fig 3.1).
• Apps: Undo, back.
• Ops: Push/pop.
• Python: List.

• Infix: A+B.
• Prefix: +AB.
• Postfix: AB+.
• BODMAS for infix.
• No parens in pre/post.
• Table 3.1 ex.

• Add top; append().
• Overflow check.
• Ex: opPush(stack, 'glass').
• Fig 3.2 push 1.
• Dynamic in Python.
• No limit.

• Remove top; pop().
• Underflow if empty.
• Ex: opPop(stack) returns elem.
• Glass ex output.
• Returns deleted.
• Check isEmpty first.

• Algo 3.1: postExp string.
• Push (, pop on ).
• Op: Prec compare, pop/append.
• Ex: Fig 3.3 steps.
• Final pop all.
• Operators only pushed.

• Algo 3.2: Push operands.
• Pop two for op, push result.
• Ex: Fig 3.4 7 8 2*4/+ =11.
• Single element final.
• Invalid if not.
• Binary ops.

• Print reversed for top-down.
• for i in range(len-1,-1,-1).
• Ex: glass3 then glass1.
• Visualize contents.
• After ops.
• Current elements msg.

• Infix: Human, BODMAS.
• Prefix: Op first, left-to-right.
• Postfix: Op last, easy eval.
• Ex: 3*(4+5) variants.
• No parens needed.
• Stack for conv/eval.

• Push on (, pop on ).
• Match pairs/nesting.
• Error if mismatch.
• Ex: Compiler check.
• LIFO perfect.
• Algo step 4.

• No checks: Underflow crash.
• Ex: Pop empty.
• Always isEmpty first.
• Debug hard.
• Use functions.
• Python list safe.

• Stack: Last in out first.
• Ex: Plates top only.
• Queue: First in out first.
• Ex: Line waiting.
• Both linear.
• Stack apps: Undo.
• Queue: BFS.
• Evidence: Ch3 intro.

• Overflow: Push full.
• Ex: Fixed size array.
• Underflow: Pop empty.
• Ex: No elems.
• Low prec: Pop higher first.
• Ex: + then * push.
• Algo 3.1.
• Fig 3.3.

• Push chars.
• Pop to new string.
• Ex: "ABC" → CBA.
• Code below.
• LIFO reverse.
• App ex.
• Efficient O(n).
• Exercise 3.

s = "ABC"
stack = []
for c in s: stack.append(c)
rev = ""
while stack: rev += stack.pop()
print(rev)  # CBA

• Push only odds.
• Pop to find max.
• Ex: Inputs 1-10 → odds stack.
• Modified code.
• Display + max.
• Hint: Pop track max.
• LIFO but max separate.
• Exercise 7.

stack = []
while True:
    n = int(input())
    if n % 2: stack.append(n)
    if n == -1: break
mx = max(stack)
while stack: print(stack.pop())
print("Max odd:", mx)

• Stack: LIFO DS.
• Ex: List impl.
• Push: Add top.
• Ex: Append.
• Conversion: Infix-postfix.
• Ex: Algo 3.1.
• Stack ops track.
• Key for expr.

• Algo 3.2 steps.
• Push ops, pop for calc.
• Ex: AB+C* A=3 B=5 C=1 → 8.
• Code below.
• Single final value.
• Fig 3.4.
• Exercise 5a.
• Binary only.

post = "3 5 + 1 *"
stack = []; tokens = post.split()
for t in tokens:
    if t.isdigit(): stack.append(int(t))
    else:
        b = stack.pop(); a = stack.pop()
        if t == '+': stack.append(a + b)
print(stack.pop())  # 8

• def opPush(stack, elem): stack.append(elem)
• def opPop(stack): return stack.pop() if stack else None
• if not isEmpty(stack): ...
• Code: Full funcs.
• Flow: Create → Push → Pop → Display.
• Glass ex.
• LIFO verify.
• Matches text.

def isEmpty(s): return len(s)==0
# Use in top/pop

• Algo 3.1: AB+CD* -.
• Steps: A append, + push (empty), etc.
• Prec: * high, pop for -.
• Ex: Exercise 6a.
• Stack changes.
• Similar TypeError.
• Debug tool.
• Ch link.

# Manual: A B + C D * -

• Add def display(s): for i in range(len(s)-1,-1,-1): print(s[i])
• After ops.
• Cleanup ex: Print all.
• Top first.
• Ex: glass3 glass1.
• Ensures view.
• Robustness.
• File prep.

• Used in C++/Java.
• LIFO for calls.
• Python: List append/pop.
• Dynamic.
• Stack search.
• Ex: Expr handlers.
• 2025: Async stacks.
• Clean LIFO.