Stacks and Queues

• The course outline requests that we cover three additional ADTs.
  • unordered/ordered lists
  • stacks
  • queues
• We will cover lists extensively soon.
• Stack
  • Characterized as first in last out (FILO)
  • Or last in first out (LIFO)
  • Or just a stack of books.
• Queue
  • Characterized as first in first out (FIFO)
  • Or a line.
• In CS (and the rest of the world) we make extensive use of these two data structures.
• The domain of each is a homogeneous collection of items ordered by time.
• Stack Operations
  • The operations on a stack of ItemT are
    • InitStack(StackT & s)

      Create an empty stack.

    • Push(StackT & s, ItemT item)

      Add an item at the top of stack (if there is space). The new item becomes the top item

    • ItemT Pop(StackT & s)

      Remove the top item from the stack and return it, if there is an item there. This will decrease the stack size by 1.

      Some definitions do not return the item.

      Dealing with errors is problematic for now.

    • ItemT Top(const StackT & s)

      Return the top item of the stack if it exists. This will not change the stack size.

    • bool IsEmpty(const StackT & s);

      Return true if the stack is empty

    • bool IsFull(const StackT & s);

      Return true if the stack is full

    • size_t Size(const StackT & s);

      Return the number of items in the stack.

  • Notes:
    • In a pure data structures discussions would remove the types.
    • Errors are difficult to handle correctly right now.
    • There are no other operations on a stack.
  • How could we implement a stack in an array
    • A structure
      • An array of ItemT, 0 ... MAX_STACK_SIZE
      • An integer containing the number of elements in the stack
        • This would also be the location to add a new element.
    • Discuss each routine.
• Queue
  • Operations for an ItemT
    • InitQueue(QueueT & q)
    • Enqueue(QueueT & q, ItemT & item);
    • ItemT Dequeue(QueueT & q);
    • ItemT Front(const QueueT & q);
    • bool IsEmpty(const QueueT & q);
    • bool IsFull(const QueueT & q);
    • int Size(const QueueT & q);