Data Structures Part 2

Stacks, Queues, Trees, and Graphs

Briana B. MorrisonCSE 1302C

Spring 2010

2CSE 1302C

Topics• Stacks• Queues• Trees and Graphs

3CSE 1302C

Classic Data Structures• Now we'll examine some classic data

structures

• Classic linear data structures include queues and stacks

• Classic nonlinear data structures include trees and graphs

4CSE 1302C

A Stack Using a Linked List• A stack is a linear data structure that

organizes items in a last in, first out (LIFO) manner.

• Items are added and removed from only one end of a stack

• Analogies: cafeteria trays are typically organized in a stack, a stack of bills to be paid

• The tray at the top of the stack was put on the stack last, and will be taken off the stack first.

5CSE 1302C

Stacks• Stacks often are drawn vertically:

poppush

6CSE 1302C

Stacks• Some stack operations:

– push - add an item to the top of the stack– pop - remove an item from the top of the stack– peek (or top) - retrieves the top item without

removing it– empty - returns true if the stack is empty

• A stack can be represented by a singly-linked list

• A stack can be represented by an array, but the new item should be placed in the next available place in the array rather than at the end

7CSE 1302C

A Stack can be Implemented using a Linked List

• In a stack implemented as a linked list:– To push, we insert at the beginning of the linked

list.– To pop, we delete the first item in the linked list.

Thus, deletion is not based on value; we always delete the first item in the list.

8CSE 1302C

PlayerStackLinkedList MethodsReturn value Method name and argument listvoid push( Player p )

inserts Player p at the top of the stack Player pop( )

returns and removes the first Player of the list. If the list is empty, the method throws a DataStructureException.

Player peek( ) returns a copy of the first Player on the list without deleting it. If the list is empty, the method throws a DataStructureException.

9CSE 1302C

A Stack Can be Implemented using an Array

• If we know in advance the maximum number of objects on the stack, we can represent the stack using an array. – This is easier to implement than a linked list.

• We add items to the stack starting at index 0.• We maintain an index top, short for top of the

stack. • The last element inserted is at index top.

10CSE 1302C

Array Representing a Stack• There are three items on the stack:

index Player object

top 2 (8, Gino, Diablo )

1 ( 7, Sarah, Mario )

0 ( 2, Jin, Golf )

11CSE 1302C

Stack after Inserting Player (6, Steve, NFL )

• Now there are four items on the stack:

index Player object

top 3 ( 6, Steve, NFL )

2 (8, Gino, Diablo )

1 ( 7, Sarah, Mario )

0 ( 2, Jin, Golf )

12CSE 1302C

Our Stack After Popping Once • Now there are three items on the stack.

Player ( 6, Steve, NFL ) is not on the stack.index Player object

3 ( 6, Steve, NFL )

top 2 (8, Gino, Diablo )

1 ( 7, Sarah, Mario )

0 ( 2, Jin, Golf )

13CSE 1302C

Instance Variables for Stack• We will have three instance variables:

– A constant STACK_SIZE, representing the capacity of the stack.

– An array stack, storing the elements of the stack.– An int top, representing the top of the stack.

public class ArrayStack { private static final int STACK_SIZE = 100; private Player [] stack; private int top; …. }

14CSE 1302C

Constructor for our Stack• The constructor does two things:

– It instantiates the array, stack.– It initializes top to -1 to reflect that the stack is

empty. If top were initialized to 0, then there would be an element on the stack, at index 0.

public ArrayStack( ) { stack = new Player[STACK_SIZE]; top = -1; // stack is empty }

15CSE 1302C

Utility Methods for our Stack• We will have three utility methods:

– isEmpty, returning true if the stack is empty.– isFull, returning true if the stack is full.– toString, returning a String representation of the

stack.

public bool isEmpty( ) { return ( top == -1 ); }

public bool isFull( ) { return ( top == ( STACK_SIZE – 1 ) ); }

16CSE 1302C

toString Method for our Stack

public String toString( ) { String stackString = ""; for ( int i = top; i >= 0; i-- ) stackString += ( i + ": " + stack[i] + "\n" ); return stackString; }

17CSE 1302C

push Method for our Stack public boolean push( Player p ) { if ( !isFull( ) ) { stack[++top] = p; return true; } else return false; }

18CSE 1302C

pop Method for our Stack public Player pop { if ( !isEmpty( ) ) return ( stack[top--] ); else throw new DSException ( "Stack empty: cannot pop" ); }

19CSE 1302C

Common Error Trap

• Do not confuse the top of the stack with the last index in the array. Array elements with array indexes higher than top are not on the stack.

20CSE 1302C

Queues• A queue is similar to a list but adds items only to

the rear of the list and removes them only from the front

• It is called a FIFO data structure: First-In, First-Out

• Analogy: a line of people at a bank teller’s window

• enqueue • dequeue

21CSE 1302C

Queues• We can define the operations for a queue

– enqueue - add an item to the rear of the queue– dequeue (or serve) - remove an item from the front of

the queue– empty - returns true if the queue is empty

• As with our linked list example, by storing generic Object references, any object can be stored in the queue

• Queues often are helpful in simulations or any situation in which items get “backed up” while awaiting processing

22CSE 1302C

Queues• A queue can be represented by a singly-

linked list; it is most efficient if the references point from the front toward the rear of the queue

• A queue can be represented by an array, using the remainder operator (%) to “wrap around” when the end of the array is reached and space is available at the front of the array

23CSE 1302C

A Queue can be Implemented using a Linked List

• In a queue implemented as a linked list, we enqueue by inserting at the end of the linked list.

• In a stack implemented as a linked list, we dequeue by deleting the first item in the linked list. Again, deletion is not based on value; it is based on position.

24CSE 1302C

A Linked List Class Implementing a Queue• Because a queue inserts items at the

end of the list, we will add an instance variable, tail, (a PlayerNode reference), representing the last node in the list. In this way, we do not have to traverse the list every time we insert an item.

• We will need to update that reference every time an item is inserted.

25CSE 1302C

A Linked List Implementing a Queue• Here is an example of a queue of Player

objects represented by a linked list.

2

Jin

Golf

8

Gino

Diablo

5

Ajay

Sonic

head

null7

Sarah

Mario

tail

26CSE 1302C

Return value Method name and argument listvoid enqueue( Player p )

inserts Player p at the end of the list Player dequeue( )

returns and removes the first Player of the list. If the list is empty, the method throws a DataStructureException

Player peek( ) returns a copy of the first Player on the list without deleting it. If the list is empty, the method throws a DataStructureException

27CSE 1302C

Inserting in a (non-empty) Linked List Representing a Queue

• Our original list:2

Jin

Golf

8

Gino

Diablo

5

Ajay

Sonic

head

null7

Sarah

Mario

tail

28CSE 1302C

Inserting in a (non-empty) Linked List Representing a Queue

• Step 1: Instantiate a new node:PlayerNode pn = new PlayerNode( p );

// here, p is Player( 6, Steve, NFL )2

Jin

Golf

8

Gino

Diablo

5

Ajay

Sonic

head

null7

Sarah

Mario

• 6• Steve• NFL

null

tail

pn

29CSE 1302C

Inserting in a Linked List Representing a Queue• Step 2: Attach the new node at the end

of the list: tail.setNext( pn );

2

Jin

Golf

8

Gino

Diablo

5

Ajay

Sonic

head

7

Sarah

Mario

6

Steve

NFL

null

tail

30CSE 1302C

Inserting in a Linked List Representing a Queue• Step 3: Update tail: tail = tail.getNext( );

2

Jin

Golf

8

Gino

Diablo

5

Ajay

Sonic

head

7

Sarah

Mario

6

Steve

NFL

null

tail

31CSE 1302C

A Linked List Class Implementing a Queue• A queue has a front and a back, represented by

head and tail, respectively.• Could they be inverted, i.e. could head represent

the back of the queue and tail represent the front of the queue?

• This would be highly inefficient because when we delete, we would need to traverse the list in order to update tail.

• Indeed, we cannot go backward in the list from tail in order to access the next-to-last node (which becomes tail after the deletion).

32CSE 1302C

Array Representation of Queues• We can also represent a queue using an array. • The first (inefficient) idea is to represent the queue

with a standard array; two indexes, front and back, represent the front and back of the queue.

• To enqueue, we could increment back by 1 and store the player at array index back.

• To dequeue, we could return the element at index front and increment front by 1.

• The problem with this approach is that the number of available elements in the array will shrink over time.

33CSE 1302C

Queue after Inserting First 5 Elements• // Player( 5, Ajay, Sonic ) was enqueued first.

index Player object

7

6

5

back 4 ( 6, Steve, NFL )

3 (8, Gino, Diablo )

2 ( 7, Sarah, Mario )

1 ( 2, Jin, Golf )

front 0 ( 5, Ajay, Sonic )

34CSE 1302C

Queue after Dequeueing Once• Element at index 0 is no longer usable.

index Player object

7

6

5

back 4 ( 6, Steve, NFL )

3 (8, Gino, Diablo )

2 ( 7, Sarah, Mario )

front 1 ( 2, Jin, Golf )

0 ( 5, Ajay, Sonic )

35CSE 1302C

Using a Circular Array• The solution is to consider the array as a

circular array.• After back reaches the last array index,

we start enqueueing again at index 0.• If the array has size 8, the index "after" 7

is 0.• The useful capacity of the array never

shrinks. If the array has size 8, the useful capacity of the array is always 8.

36CSE 1302C

An Empty Queue

37CSE 1302C

Enqueueing One Element

38CSE 1302C

Enqueueing a Second Element

39CSE 1302C

Enqueueing a Third Element

40CSE 1302C

Enqueueing a Fourth Element

41CSE 1302C

Dequeueing Once

42CSE 1302C

Dequeueing Again

43CSE 1302C

Full Queue• In a queue implemented as a circular

array, how do we know when the queue is full?

• When the queue is full, we have the following relationship between front and back:

( back + 1 – front ) % QUEUE_SIZE == 0

44CSE 1302C

A Full Queue

45CSE 1302C

Empty Queue• When the queue is empty, we also have

the same relationship between front and back!

( back + 1 – front ) % QUEUE_SIZE == 0

46CSE 1302C

An Empty Queue

47CSE 1302C

Queue Full or Empty?• So when ( back + 1 – front ) % QUEUE_SIZE == 0

• Is the queue full or empty? We cannot tell.

• There is an easy way to solve this problem: Keep track of the number of items in the queue.

48CSE 1302C

Instance Variables for our Queue• We will have five instance variables:

– A constant representing the capacity of the queue.– An array, storing the elements of the queue.– An int, front, representing the front of the queue.– An int, back, representing the back of the queue.– An int, numberOfItems, storing the number of items in

the queue. public class ArrayQueue { private static final int QUEUE_SIZE = 8; private Player [] queue; private int front; private int back; private int numberOfItems; … }

49CSE 1302C

Constructor for our Queue• The constructor does four things:

– instantiates the array, queue.– initializes front to 0– initializes back to QUEUE_SIZE – 1– initializes numberOfItems to 0 to reflect that

the queue is empty.

public ArrayQueue( ) { queue = new Player[QUEUE_SIZE]; front = 0; back = QUEUE_SIZE - 1; numberOfItems = 0; }

50CSE 1302C

Utility Methods for our Queue• We will have three utility methods:

– isEmpty, returning true if the the queue is empty.– isFull, returning true if the the queue is full.– toString, returning a String representation of the queue.

public boolean isEmpty( ) { return ( numberOfItems == 0 ); }

public boolean isFull( ) { return ( numberOfItems == QUEUE_SIZE ); }

51CSE 1302C

toString Method for our Queuepublic String toString( ) { String queueString = ""; if ( back >= front ) { for ( int i = front; i <= back; i++ ) queueString += queue[i] + "\n"; } else { for ( int i = front; i < QUEUE_SIZE; i++ ) queueString += queue[i] + "\n"; for ( int i = 0; i <= back; i++ ) queueString += queue[i] + "\n"; } return queueString; }

52CSE 1302C

enqueue Method for our Queue public boolean enqueue( Player p ) { if ( !isFull( ) ) { queue[( back + 1 )% QUEUE_SIZE] = p; back = ( back + 1 ) % QUEUE_SIZE; numberOfItems++; return true; } else return false; }

53CSE 1302C

dequeue Method for our Queue public Player dequeue throws DataStructureException { if ( !isEmpty( ) ) { front = ( front + 1 ) % QUEUE_SIZE; numberOfItems--; return queue[( QUEUE_SIZE + front – 1 ) % QUEUE_SIZE]; } else throw new DataStructureException ( "Queue empty: cannot dequeue" ); }

54CSE 1302C

Common ErrorTrap

• Do not confuse array index 0 and QUEUE_SIZE - 1 with front and back. In a queue represented by a circular array, the indexes 0 and QUEUE_SIZE - 1 are irrelevant.

55CSE 1302C

Implementing a Stack or a Queueas an Array vs as a Linked List

Array Linked List

Easily expandable No Yes

Direct access to every item Yes No

Easy to code Yes No

56CSE 1302C

Trees• A tree is a non-linear data structure that

consists of a root node and potentially many levels of additional nodes that form a hierarchy

• Nodes that have no children are called leaf nodes

• Nodes except for the root and leaf nodes are called internal nodes

• In a general tree, each node can have many child nodes

57CSE 1302C

Binary Trees• In a binary tree, each node can have no more than

two child nodes

• A binary tree can be defined recursively. Either it is empty (the base case) or it consists of a root and two subtrees, each of which is a binary tree

• Trees are typically are represented using references as dynamic links, though it is possible to use fixed representations like arrays

• For binary trees, this requires storing only two links per node to the left and right child

58CSE 1302C

Tree Example - Starcraft

59CSE 1302C

Dungeon Siege 2

60CSE 1302C

Diablo 2

61CSE 1302C

Fallout 3

62CSE 1302C

Visiting Every Nodevoid PrintTree (Node current)

{ if (current != null)

{ Console.WriteLine(current.data)

PrintTree(current.left);

PrintTree(current.right);

}

} • Of course we could order the 3 statements of work

in any order, visiting the nodes in a different order.• Not to be missed: http://oracleofbacon.org/

63CSE 1302C

Graphs• A graph is a non-linear structure

• Unlike a tree or binary tree, a graph does not have a root

• Any node in a graph can be connected to any other node by an edge

• Analogy: the highway system connecting cities on a map

64CSE 1302C

Digraphs• In a directed graph or digraph, each

edge has a specific direction.

• Edges with direction sometimes are called arcs

• Analogy: airline flights between airports

65CSE 1302C

Representing Graphs• Both graphs and digraphs can be

represented using dynamic links or using arrays.

• As always, the representation should facilitate the intended operations and make them convenient to implement

66CSE 1302C

Collection Classes• The C# standard library contains several

classes that represent collections, often referred to as the Generic Collection

• Their underlying implementation is implied in the class names such as ArrayList and LinkedList

67CSE 1302C

Stacks• The System.Collections.Generic;

package contains a Stack class

• Like ArrayList operations, the Stack operations operate on Object references

68CSE 1302C

Questions?