CPSC 221

Stacks

Today

Announcements

• PA1 is due tonight, 11:59 pm
• Examlet 3 runs Thursday to Sunday — book your seat on PrairieTest
• PEX3 is posted

Where we’re going

• Stacks
• The Stack ADT
• Two implementations
• The Witch’s Potion Pantry

Stacks

The spring-loaded plate dispenser (a real patent drawing): you only ever touch the top plate. That is the whole ADT.

Then the call stack. Walk main → studyHard → pas → plan, and fill in the empty column as calls go on and come off. Every program they have ever run has used a stack.

Two classic uses along the bottom, worth naming and leaving for later: balanced brackets, and evaluating postfix (4 5 + 7 2 - * 3 - 6 /).

Abstract Data Type:

Stack ADT:

template<class LIT>
class Stack {
public:
    Stack();  // ~Stack, cctor, op=?
    bool empty() const;
    void push(const LIT & e);
    LIT pop();
private:

    //  ?

};

push(3)
push(8)
push(4)
pop()
pop()
push(6)
pop()
push(2)
pop()
pop()

Push 1, 2, 3 in order, with interleaved pops. What output is impossible?

Trace the sequence on the right: the pops return 4, 8, 6, 2, 3.

The question at the bottom: pushing 1, 2, 3 in order, 3 1 2 is the only impossible output. Once 3 has come off, 2 is on top of 1, so 1 cannot come out before 2.

The private: section is a question mark on purpose. The next two slides are two different answers to it.

Stack linked memory implementation:

template<class LIT>
class Stack {
public:
    Stack();  // ~Stack, cctor, op=?
    bool empty() const;
    void push(const LIT & e);
    LIT pop();
private:
    struct Node {
        LIT data;
        Node * next;
    };
    Node * top;
    int size;
};

template<class LIT>
LIT Stack<LIT>::pop() {




}

template<class LIT>
void Stack<LIT>::push(LIT d) {
    Node * newN = new Node(d);
    newN->next = top;
    top = newN;
    size++;
}

The top of the stack is the front of the list. push is insertAtFront from lecture 9, almost word for word.

pop, filled in:

LIT retval = top->data;
Node * old = top;
top = top->next;
delete old;
size--;
return retval;

Save the value before deleting the node. Both operations are \(\Theta(1)\): nothing is ever traversed.

Stack array based implementation:

template<class LIT>
class Stack {
public:
    Stack();  // ~Stack, cctor, op=?
    bool empty() const;
    void push(const LIT & e);
    LIT pop();
private:
    vector<LIT> items;
};

template<class LIT>
LIT Stack<LIT>::pop() {
    LIT retval = items[_____];
    items.pop_back();
    return retval;
}

template<class LIT>
void Stack<LIT>::push(LIT d) {

    items.push_back(d);

}

The top of the stack is the back of the vector. The blanks are top and items.size()-1.

pop is \(\Theta(1)\). push is \(\Theta(1)\) as long as there is room. When the array fills, the vector resizes, which is Nathan’s video from Friday: double the capacity and push is still \(\Theta(1)\) on average.

The two implementations have the same interface and very different insides. That is the ADT point from the last slide, made concrete.

Get ready

Open PrairieLearn now: Class Activities → The Witch’s Potion Pantry

Click Open workspace — it takes a minute to start, so let it load while you watch the story.

Doing this before the story matters. A whole section launching workspaces in the same minute is the slowest part of the activity, and the first launch has to pull the C++ image.

Click into the story to give it focus, then → or Enter to advance. ?step=N in the iframe URL jumps to scene N if you need to resume.

The two halves are the two parts of the puzzle: the ghost carries one jar at a time (Part 1), the witch lifts the whole group at once (Part 2). Point at shelf 3 at the end of each half — K R B W versus K R W B. Same moves, the pair swaps order.

Your Turn

Every one of you has your own pantry and your own recipe!

• In potions.cpp, write part1 and part2 — using std::stack.

• make example should print CMZ and MCD.

• make input reveals your words!

std::stack splits our pop in two: top() reads the top item, and pop() removes it and returns nothing. Worth saying before they start, or the first ten minutes are compile errors.

Part 1 is a direct translation. Part 2 is the point: a stack will not lift a block and set it down in order. The move is a second, temporary stack — pop the group into it, which reverses it, then pop it onto the destination, which reverses it back. Let them find it.

Full credit 2:00–3:59 today (both sections); open afterwards for practice at zero credit.

Today, you built a data structure

Defined	the Stack ADT: push, pop, empty. Last in, first out
Implemented	two ways: linked list and vector
Analyzed	push and pop are \(\Theta(1)\) for linked list. For the vector, doubling on resize keeps the functions \(\Theta(1)\) on average.
Applied	Potion Pantry: use a stack to reverse the pile!

Point at the four verbs. That is the life cycle of every structure for the rest of the term: define the ADT, implement it, analyze it, use it.

The Part 2 trick is worth one more sentence: popping a group into a temporary stack reverses it; popping it onto the destination reverses it back. Two reversals, original order.