Stacks & Queues

0. General concepts

1. Stacks

• Linear/sequential structure with LIFO (last-in first-out) behavior.
• Only 1 access point for insertion/deletion/access -- top of the stack
• Typical operations: push (insertion), pop (deletion), top (peek the top)

  Assuming a char array stack,

       +---+         +---+         +---+        +---+         +---+
       |   | 2       |   | 2       |   | 2      |   | 2       |   |
       +---+         +---+         +---+        +---+         +---+
       |   | 1       |   | 1  top->| B | 1 top->| B | 1       | B | 1
       +---+         +---+         +---+        +---+         +---+
       |   | 0  top->| A | 0       | A | 0      | A | 0  top->| A | 0
       +---+         +---+         +---+        +---+         +---+
  top->       
  
      initial       push 'A'      push 'B'       top           pop
  
  RETURNED                                       'B'

• Typical applications:
  1. Reversing a sequence 
     • How can you reverse a string using a stack?
  2. Checking things that must be balanced (e.g., {{ }} )
     • How can you check for balanced symbols in Java, /* */, ( ), [ ], { } (all of them at once) using a stack?
     • Can you accomplish the same task by using counters instead of stack?
  3. Postfix expressions -- evaluation using a stack
     • Some examples of infix/prefix/postfix expressions

       Infix	Prefix	Postfix
       3 + 5	(+ 3 4)	3 4 +
       3 + (4 * 5)	(+ 3 (* 4 5))	3 4 5 * +
       (3 + 4) * 5	(* (+ 3 4) 5)	3 4 + 5 *

• Implementation example: Textbook p. 149 (using a linked list)

  public class Stack<Item>  {
    private int N;      // size of the stack
    private Node first; // top of stack
  
    // helper linked list class
    private class Node {
      private Item item;
      private Node next;
    }
  
    public Stack() { first = null; N = 0; }
    public boolean isEmpty() { return first == null; }
    public int size() { return N; }
  
    public void push(Item item) {
      Node oldfirst = first;
      first = new Node();
      first.item = item;
      first.next = oldfirst;
      N++;
    }
  
    public Item pop() {
      if (isEmpty()) throw new NoSuchElementException("Stack underflow");
      Item item = first.item;        // save item to return
      first = first.next;            // delete first node
      N--;
      return item;                   // return the saved item
    }
  
    public Item peek() {
      if (isEmpty()) throw new NoSuchElementException("Stack underflow");
      return first.item;
    }
  }

• Java Stack<E> -- an imepelented class, in java.util package.  Operations include:
  • Stack() -- constructor with zero parameter
  • boolean empty()
  • E push(E item)
  • E peek()
  • E pop()

3. Queues

• Linear/sequential structure with FIFO (first-in first-out) behavior.
• 2 access points -- front and back
• Typical operations: enqueue (for insertion, at back), dequeue (for deletion, at front), getFront 

  Assuming a char queue, (F for front, B for back)

  initial       +---+---+---+---+-
  empty         |   |   |   |   | 
  queue         +---+---+---+---+-
              ^   ^
              |   |
              B   F
  
                +---+---+---+---+-
  enqueue 'p'   | p |   |   |   | 
                +---+---+---+---+-
                 ^ ^
                 | |
                 B F
  
                +---+---+---+---+-
  enqueue 'd'   | p | d |   |   | 
                +---+---+---+---+-
                  ^   ^
                  |   |
                  F   B
  
                +---+---+---+---+-
  dequeue       | p | d |   |   | 
                +---+---+---+---+-
                     ^ ^
                     | |
                     F B
  
                +---+---+---+---+-
  enqueue 'c'   | p | d | c |   | 
                +---+---+---+---+-
                       ^  ^
                       |  |
                       F  B

• Sometimes queues are implemented as circular queue -- Since front/back indices go rear-ward always, we run out of (array) space. So make the indices to wrap around.
• Typical applications:
  • Any "queue" tasks, such as print queue, process scheduling -- often their real-world simulations
• Implementation example: Textbook p. 151 (using a linked list, and with front AND back references)

  public class Queue<Item> {
    private int N;       // number of elements on queue
    private Node first;  // beginning of queue
    private Node last;   // end of queue
  
    // helper linked list class
    private class Node {
      private Item item;
      private Node next;
    }
  
    public Queue() { first = null; last  = null; N = 0; }
    public boolean isEmpty() { return first == null; }
    public int size() { return N; }
  
    public Item peek() {
      if (isEmpty()) throw new NoSuchElementException("Queue underflow");
      return first.item;
    }
  
    public void enqueue(Item item) {
      Node oldlast = last;
      last = new Node();
      last.item = item;
      last.next = null;
      if (isEmpty()) first = last;
      else           oldlast.next = last;
      N++;
    }
  
    public Item dequeue() {
      if (isEmpty()) throw new NoSuchElementException("Queue underflow");
      Item item = first.item;
      first = first.next;
      N--;
      if (isEmpty()) last = null;   // to avoid loitering
      return item;
    }
  }

• Java Queue<E> -- an interface, in java.util package.  Operations include:
  • boolean isEmpty() -- inferited from java.util.Collection
  • boolean add(E item)
  • E peek()
  • E remove()