The first implementation uses an array to create the stack
data structure, and the second implementation uses pointers.

Array Implementation

In order to implement a stack using an array, we need to reserve a
block of memory cells large enough to hold all the items we want to
put on the stack. The picture below shows an array of six memory cells
that represent our stack. Notice that we have one other memory cell
called a stack pointer that holds the location of the top of our stack.
As the stack grows and shrinks, this pointer is updated so that it always
points to the top item of the stack.

Notice that our array implementation retains one of the problems we
saw with the array implementation of an ordered list. Since our array
is a fixed size, our stack can only grow to a certain size. Once our
stack is full, we will have to use the PopStackItem operation
before we can push any more items onto the stack. To make the size of
our stack more flexible, we can use pointers to implement the stack.

Pointer Implementation

In order to implement a stack using pointers, we need to link nodes
(groups of memory cells) together just like we did for the pointer implementation
of a list. Each node contains a stack item and a pointer to the next
node. We also need a special pointer to keep track of the top of our
stack.

Notice that the stack operations can get a little tricky when we use
pointers. To push an item onto the stack, we need to find a free memory
location, set the pointer of the new location to the top of the stack,
and finally set the stack pointer to the new location. The order of
these operations is very important. If we set the stack pointer to the
location of the new memory first, we will lose the location of the top
of our stack. This example shows the same tradeoff that we saw earlier
with the ordered list implementations. While the array implementation
is simpler, the added complexity of the pointer implementation gives
us a more flexible stack.

In our last lesson, we discovered a problem with representing data structures that are not linear. We need some way to map these data structures to the computer’s linear memory. One solution is to use pointers. Pointers are memory locations that are stored in memory cells. By using a pointer, one memory cell can “point” to another memory cell by holding a memory address rather than data. Let’s see how it works.

In the diagram above, the memory cell at address 2003 contains a pointer, an address of another cell. In this case, the pointer is pointing to the memory cell 2005 which contains the letter ‘c’. This means that we now have two ways of accessing the letter ‘c’ as stored data. We can refer to the memory cell which contains ‘c’ directly or we can use our pointer to refer to it indirectly. The process of accessing data through pointers is known as indirection. We can also create multiple levels of indirection using pointers. The diagram below shows an example of double indirection. Notice that we must follow two pointers this time to reach the stored data.

As you can see, pointers can become very complex and difficult to use with many levels of indirection. In fact, when used incorrectly, pointers can make data structures very difficult to understand. Whenever we use pointers in constructing data structures, we have to consider the tradeoff between complexity and flexibility. We will consider some examples of this tradeoff in the next few lessons.

The idea of pointers and indirection is not exclusive to computer memory. Pointers appear in many different aspects of computer use. A good example is hyperlinks in web pages. This links are really pointers to another web page. Perhaps you have even experienced “double indirection” when you went to visit a familiar web site and found the site had moved. Instead of the page you expected, you saw a notice that the web pages had been moved and a link to the new site. Rather than clicking a single link, you had to follow two links or two pointers to reach the web page.

Another common linear data structure is the stack. Just like we did
with the ordered list, we will examine the abstract view of a stack
first and then look at a couple of ways a stack can be implemented.
In one way, a stack is very similar to a list except that a stack is
more restricted. The animation below should give you a good idea of
the abstract view of a stack. Follow the directions to manipulate a
simple stack and learn about the operations that a stack provides.

Press here to see how to use Stack (Flash Movie)

Now that you know how a stack works, you can see that this data structure
is really a restricted list. With the stack, we have restricted the
access to one end of the list by using the pop and push operations.
The result of this restriction is that items in the list pile one on
top of the other. To get to the bottom item, we must first remove all
the items above it. This behavior is sometimes described as “last-in,
first-out” or LIFO since the last item to enter the stack is the
first item to leave the stack. With the stack, the top item is always
the last item to enter the stack and it is always the first item to
leave the stack since no other items can be removed until the top item
is removed.

Let’s take another look at the operations that can be performed on
a stack. We will represent these two operations with the following notation:

Item PushStackItem(Stack,
Item)

Item PopStackItem(Stack)

The PushStackItem operation has two parameters which are a stack
and an item. This operation adds the item to the top of the specified
stack. The PopStackItem operation only takes one parameter which
is a stack. However, notice that this operation has the keyword Item
listed to the left. This keyword represents the item that is removed
from the top of the stack when the PopStackItem operation is
done. These two operations are part of the abstract view of a stack.
They are what we expect from any stack regardless of how it is implemented
in the computer.