Abstract Data Types

Q: What data structure employs the FIFO (first-in, first-out) paradigm?
A: a queue

Stack Implementation #3

A third version (array) using a template class: (almost identical to the first implementation)

template <typename Item> class Stack3 { private: Item *items; int size; public: Stack3(int capacity) { items = new Item[capacity]; size = 0; } ~Stack3() { delete[] items; } void Push(Item item) { items[size++] = item; } Item Pop() { return items[--size]; } bool IsEmpty() { return (size == 0); } };

class Stack1 { private: char *items; int size; public: Stack1(int capacity) { items = new char[capacity]; size = 0; } ~Stack1() { delete[] items; } void Push(char item) { items[size++] = item; } char Pop() { return items[--size]; } bool IsEmpty() { return (size == 0); } };

Client code is almost identical:

int main()
{
  const int SIZE = 10;
  Stack3<char> stack(SIZE); // This is the only change

  char *p = "ABCDEFG";

  for (unsigned int i = 0; i < strlen(p); i++)
    stack.Push(p[i]);

  while (!stack.IsEmpty())
    cout << stack.Pop();

  cout << endl;

  return 0;
}

The output:
GFEDCBA

An advantage of this implementation:

int main() { const int SIZE = 5; Stack3<int> stack(SIZE); for (unsigned int i = 1; i <= SIZE; i++) { cout << 1000 * i << endl; stack.Push(1000 * i); } cout << endl; while (!stack.IsEmpty()) cout << stack.Pop() << endl; return 0; }

The output: 1000 2000 3000 4000 5000 5000 4000 3000 2000 1000

In this implementation:

The client code changes only slightly (but only once and it's simple)
Still no error checking.
It's still an array, so we have pros/cons of that data type (complexity, growth).
Accepts any data type (almost).
Templates in C++ can potentially generate a lot of code.

Stack Implementation #4

A fourth implementation using linked-lists of generic pointers.

We use this Node structure:

struct Item
{
  Item *next;
  void *data;
};

Similar to the second version, change CharItem to Item (generic)
The data is untyped (void *)
Many frameworks are implemented this way.
Simpler than a template class (not C++ specific) with possibly less memory requirements, but not as safe.
Many languages have pointers, very few have generic programming (templates in C++.)

The interface/implementation:

class Stack4
{
  private:
    Item *head;
    int size;
    int capacity;
  public:
    Stack4(int capacity)
    {
      head = 0;
      size = 0;
      this->capacity = capacity;
    }

    ~Stack4()
    {
      // walk the list and delete each item
      while (head)
      {
        Item *t = head->next;
        Free(head);
        head = t;
      }
    }

    void Push(void *data)
    {
      if (size >= capacity)         // stack is full
        return;                     //   do nothing

      Item *item = Allocate();// allocate new item

      item->data = data;            // insert new item at head
      item->next = head;
      head = item;
      size++;
    }

    void *Pop()
    {
      void *p = head->data; // get top item
      Item *temp = head;    // update head
      head = head->next;
      Free(temp);     // deallocate
      return p;
    }

    bool IsEmpty()
    {
      return (head == 0);
    }
};

Client using the fourth implementation:

int main()
{
  const int SIZE = 10;
  Stack4 stack(SIZE);

  char *p = "ABCDEFG";

  for (unsigned int i = 0; i < strlen(p); i++)
    stack.Push(&p[i]); // push address of data;

  while (!stack.IsEmpty())
  {
    char *c = (char *) stack.Pop();
    cout << *c; // dereference data;
  }

  cout << endl;

  return 0;
}

The output:
GFEDCBA

A less trivial example:

struct TStudent
{
  float GPA;
  int ID;
  int Year;
};

int main()
{
  const int SIZE = 5;
  Stack4 stack(SIZE);

  for (int i = 0; i < SIZE; i++)
  {
    TStudent *ps = new TStudent;
    ps->GPA = GetRandom(100, 400) / 100.0;
    ps->ID = GetRandom(1, 1000);
    ps->Year = GetRandom(1, 4);
    cout << "Student ID: " << ps->ID << ", Year: " << ps->Year << ", GPA: " << ps->GPA << endl;
    stack.Push(ps);
  }

  cout << endl;

  while (!stack.IsEmpty())
  {
    TStudent *ps = (TStudent *) stack.Pop();
    cout << "Student ID: " << ps->ID << ", Year: " << ps->Year << ", GPA: " << ps->GPA << endl;
  }

  return 0;
}

The output:
Student ID: 468, Year: 3, GPA: 1.41
Student ID: 170, Year: 1, GPA: 1.12
Student ID: 359, Year: 3, GPA: 1.4
Student ID: 706, Year: 2, GPA: 1.83
Student ID: 828, Year: 2, GPA: 2.04

Student ID: 828, Year: 2, GPA: 2.04
Student ID: 706, Year: 2, GPA: 1.83
Student ID: 359, Year: 3, GPA: 1.4
Student ID: 170, Year: 1, GPA: 1.12
Student ID: 468, Year: 3, GPA: 1.41

Considerations with this implementation:

The implementation is simple and will deal with any (pointer) data.
The overhead may be significant, but can be memory efficient if implemented as an array (memory manager).
The memory usage of the stack is independent of the size of the data (always sizeof(void *)).
This class is not as type-safe as a template class.
The client will always interact in the same way, that is, pushing addresses.

Self-check Evaluate the expression: 5 9 8 + 4 6 * * 7 + * using a stack where you push and pop from the top.

Self-check Modify the Evaluate function above to support subtraction and division as well. (Note: You'll need to pay attention to the order of operands.) Try it with

"2 * 8 / 4 + 5 * 6 - 8" which is "2 8 * 4 / 5 6 * + 8 -" in postfix.

Converting Infix to Postfix

Note that the only symbols that exist on the stack are operators and left parentheses. Operands and right parentheses are never pushed onto the stack.

Self-check - Implement a function that converts an infix expression into a postfix expression. (Hint: You will want to use a stack class. Duh.) Use your implementation to convert this infix expression to postfix: (7 + 5) * (3 + 4) - (4 * (9 - 2))

Self-check Evaluate the expression: 5 9 8 + 4 6 * * 7 + * using a queue (instead of a stack like above) where you add to the back, but remove from the front.

Self-check Using the class interface below, implement the Queue as a circular array.

However, the complexity of the algorithms depends on how the list/array is implemented. (Sorted vs. unsorted).

Here's a sample application using the Priority Queue. (Assume that PQList keeps the list sorted.)

Linked list		Array
struct PQNode { PQNode next; int* data; }; class PQList { private: PQNode list_; int* capacity_; int count_; public: // public interface (same as the array) };		class PQArray { private: int array_; int* capacity_; int count_; public: // public interface (same as the list) };

Self-check Using the class interface above, implement two priority queues. One using an array and one using a linked list. You can decide whether or not to keep it sorted.

What is the complexity when adding items to the queue when implemented as an unsorted array? Sorted array?
What is the complexity when adding items to the queue when implemented as an unsorted linked-list? Sorted List?
What is the complexity when removing items from the queue when implemented as an unsorted array? Sorted array?
What is the complexity when removing items from the queue when implemented as an unsorted linked-list? Sorted List?

Realize that adding and removing requires two actions. The first is locating the item.

Abstract Data Types

Pushdown Stack ADT

Converting Infix to Postfix