Purpose

Stacks and queues are temporally ordered container types. Elements are removed in an order based upon the order in which they were added.

• Stacks remove the last element added first. They use a LIFO (Last in First out) ordering.
• Queues remove the first element added first. They use a FIFO (First in First out) ordering.

Implementaion

There are many ways to implement Stacks and Queues. We looked at some of them last time in class.

• Stacks
  1. Using lists, using cons (:) to add elements to the front of the list.
  2. Using Arrays and a top pointer to store the next available slot.
  3. A method we did not discuss uses pointers.
• Queues
  1. Using lists, using append (++) to add elements to the back of the list.
  2. Using a pair of lists. One representing the front of the Q, and the other representing the reverse of the end of the Q.
  3. Using Arrays and front, and rear pointers to store the next available slot, and the slot storing the next element to remove.
  4. A method we did not discuss uses pointers.

Performance

Ideally we would like all operations of adding and removing from stacks and Queues to take constant time, independent of the size of the stack or queue. What implementation method fails this test?

Pure v.s. Commands

Both stacks and queues can be given both pure and command based implementations.

• Pure implementations are usually based upon lists. A pure implementation returns both a value and a new stack or queue. We can see this in the contracts of list based implementations.
  1. add:: a -> Stack a -> Stack a
  2. remove:: Queue a -> (a,Queue a)
  Note there is no IO in the type of these operators.
• Command based implementations are usually based upon arrays or pointers, since they can potentially change the state of the observable world. There are basically two types. Completely command based and hybrid.
  1. Hybrid.The array based implementation of stacks we saw in class, and the array based implementation of Queues in the homework are hybrid, since the array was command based but the top (in case of stack) and the front, rear and full (in the case of queues) were pure.

     1.  data ArrStack a = ArrStack Int Int (Array a)

     2.  data ArrQueue a = ArrQueue Int       -- index just to the left of the front element (if one exists)
               Int       -- index of the last element (if one exists)
               Int       -- low bound of the array
               Int       -- high bound of the array
               Bool      -- is the Queue full
               (Array a) -- the array that stores the elements
                            

     This also shows in the type of operations. Like pure based implementations, we need to return new Stacks and Queues (in order to update the top, front, rear, etc).
     1. addStack :: a -> ArrStack a -> IO (ArrStack a)
     2. delStack :: ArrStack a -> IO (a,ArrStack a)
     The advantages of this kind of implementation are that we can test certain properties (i.e. where the next element goes, is the structure full or empty) without using a command.
     1. isEmpty:: Stack a -> Bool
  2. Completely command based implementations store the top, front, rear, etc in mutable variables just like the elements of the arrays. This way operations don't need to return new stacks and queues, since all the elements are updated by mutation.
     1. data ArrStack2 a = ArrStack2 (Ptr Int) (Ptr Int) (Array a)
     2. addStack :: a -> ArrStack a -> IO ()

Demos of several stack and queue implementations.

• Array based stack demo see demoSt
• Array Based queue demo see demoQ
• Two list based queue demo see demoQ2

Back to the class web-page.