Lecture 15: Stacks, Queues, and Abstract Data Types

## Where Lecture 14 ended · Insertion at the head is a stack

~~~cpp
Node* head = nullptr;
for (int reading : {31, 29, 33, 30}) head = new Node{reading, head};   // insert at the head
// list: 30 33 29 31  -- the last reading inserted is the first in the list
~~~

- Insert at the head and remove from the head: the last item in is the first item out. That is a **stack**, and the list already implements it.
- The program using it needs only three operations, not the nodes: `push`, `pop`, `top`.
- **Today's question:** which operations does the program need, and what does each cost? Plan: a stack, a queue, the interface that hides the representation, then a cost table.

## Check brackets with a stack · The last one opened closes first

~~~cpp
#include <iostream>
#include <stack>
#include <string>

bool balanced(const std::string& text) {
    std::stack<char> open;
    for (char c : text) {
        if (c == '(' || c == '[' || c == '{') {
            open.push(c);
        } else if (c == ')' || c == ']' || c == '}') {
            if (open.empty()) return false;          // nothing to close
            char o = open.top();
            open.pop();
            bool ok = (o == '(' && c == ')') || (o == '[' && c == ']') || (o == '{' && c == '}');
            if (!ok) return false;                   // wrong kind of closer
        }
    }
    return open.empty();                             // anything left is unclosed
}

int main() {
    for (std::string s : {"a[i] = (b + c) * {d}", "(]", "((x)", "x)"})
        std::cout << s << " -> " << (balanced(s) ? "balanced" : "not balanced") << '\n';
}
~~~

~~~text
a[i] = (b + c) * {d} -> balanced
(] -> not balanced
((x) -> not balanced
x) -> not balanced
~~~

An opener waits on the stack. The next closer must match the **most recent** opener, which is exactly what `top()` returns. The invariant: the stack holds the openers not yet closed, innermost on top.

## Stack · Last in, first out (LIFO)

- `push` puts an item on top; `top` reads the item on top; `pop` removes it. Only the top is reachable.
- Function calls behave this way: the function called last returns first (Lecture 16 shows the call stack).
- An undo history is a stack: each edit is pushed, and Undo pops the most recent one.
- With a linked list, `push` is insertion at the head and `pop` is removal of the head, so each takes the same few steps for any length: O(1).

## Queue · First in, first out (FIFO)

- `push` adds at the back; `front` reads the earliest item; `pop` removes it from the front.
- Waiting lines are queues: print jobs, network requests, tasks served in arrival order.
- A linked queue keeps pointers to the first and last nodes; a circular array keeps `front`, `rear`, and `count`. Either gives O(1) `push` and `pop`.
- Textbooks name the operations enqueue and dequeue; `std::queue` calls them `push` and `pop`.

## Common errors · Reading or removing from an empty container

~~~cpp
std::stack<int> s;
s.push(7);
s.pop();
if (!s.empty()) std::cout << s.top() << '\n'; else std::cout << "empty: no top\n";
assert(!s.empty() && "pop requires a non-empty stack");
s.pop();                                         // pre-condition violated
~~~

~~~text
empty: no top
Assertion failed: (!s.empty() && "pop requires a non-empty stack"), function main, file a5.cpp, line 10.
~~~

The assertion text is implementation-specific (here: Apple clang), and it appears on standard error.

| Error | Example | Result |
|---|---|---|
| `top()` on an empty stack | `std::stack<int> s; s.top();` | undefined behavior |
| `pop()` on an empty stack or queue | `q.pop();` with nothing queued | undefined behavior |
| `front()` or `back()` on an empty queue | `q.front();` | undefined behavior |
| Expecting `pop()` to return the item | `int x = s.pop();` | does not compile: `pop` returns `void` |

Non-empty is the **pre-condition** of `top`, `front`, and `pop` (Lecture 12). Check `empty()` first, or `assert` it where the caller guarantees it.

## Questions about stacks and queues

| Question | Answer |
|---|---|
| Why does `pop()` not return the item? | Returning by value could throw while copying, after the item is already removed, and the item would be lost. So you read with `top()`, then remove with `pop()`. |
| Can I loop over a stack or queue? | Not directly: there are no iterators. Drain it with `while (!s.empty())`, or keep a `std::vector` if you need to traverse. |
| Is `std::stack` a container? | It is a container adaptor: it wraps a container (`std::deque` by default) and exposes only the stack operations. |
| Stack or queue: how do I choose? | Ask which item must come out next. The newest (undo, matching brackets): stack. The oldest (print jobs, requests): queue. |
| Is O(1) always faster than O(n)? | Not for tiny inputs. It says how the cost grows with n, so it matters as n gets large. |
| Where does a stack appear besides `std::stack`? | Function calls form a call stack, which Lecture 16 uses to explain recursion. |