- 50 Views
- Uploaded on
- Presentation posted in: General

Data Structures Part 2

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Data Structures Part 2

Stacks, Queues, Trees, and Graphs

Briana B. Morrison

CSE 1302C

Spring 2010

- Stacks
- Queues
- Trees and Graphs

- Now we'll examine some classic data structures
- Classic linear data structures include queues and stacks
- Classic nonlinear data structures include trees and graphs

- 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.

push

pop

- Stacks often are drawn vertically:

- 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

- 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.

- 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.

- There are three items on the stack:

- Now there are four items on the stack:

- Now there are three items on the stack. Player ( 6, Steve, NFL ) is not on the 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 inttop, representing the top of the stack.
public class ArrayStack

{

private static final int STACK_SIZE = 100;

private Player [] stack;

private int top;

….

}

- 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

}

- 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 boolisEmpty( )

{

return ( top == -1 );

}

public boolisFull( )

{

return ( top == ( STACK_SIZE – 1 ) );

}

public String toString( )

{

String stackString = "";

for ( int i = top; i >= 0; i-- )

stackString += ( i + ": "

+ stack[i] + "\n" );

return stackString;

}

public boolean push( Player p )

{

if ( !isFull( ) )

{

stack[++top] = p;

return true;

}

else

return false;

}

public Player pop

{

if ( !isEmpty( ) )

return ( stack[top--] );

else

throw new DSException

( "Stack empty: cannot pop" );

}

- 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.

dequeue

enqueue

- 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

- 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

- 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

- 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 dequeueby deleting the first item in the linked list. Again, deletion is not based on value; it is based on position.

- 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.

- Here is an example of a queue of Player objects represented by a linked list.

7

Sarah

Mario

5

Ajay

Sonic

8

Gino

Diablo

2

Jin

Golf

null

head

tail

- Our original list:

7

Sarah

Mario

5

Ajay

Sonic

8

Gino

Diablo

2

Jin

Golf

null

head

tail

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

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

7

Sarah

Mario

8

Gino

Diablo

5

Ajay

Sonic

2

Jin

Golf

null

head

tail

6

Steve

NFL

null

pn

- Step 2: Attach the new node at the end of the list:
tail.setNext( pn );

8

Gino

Diablo

6

Steve

NFL

7

Sarah

Mario

5

Ajay

Sonic

2

Jin

Golf

null

head

tail

- Step 3: Update tail:
tail = tail.getNext( );

7

Sarah

Mario

5

Ajay

Sonic

8

Gino

Diablo

6

Steve

NFL

2

Jin

Golf

null

head

tail

- 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).

- 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.

- // Player( 5, Ajay, Sonic ) was enqueued first.

- Element at index 0 is no longer usable.

- 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.

- 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

- When the queue is empty, we also have the same relationship between front and back!
( back + 1 – front ) % QUEUE_SIZE == 0

- 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.

- 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 intnumberOfItems;

…

}

- 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;

}

- 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 booleanisEmpty( )

{

return ( numberOfItems == 0 );

}

public booleanisFull( )

{

return ( numberOfItems == QUEUE_SIZE );

}

public 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;

}

public booleanenqueue( Player p )

{

if ( !isFull( ) )

{

queue[( back + 1 )% QUEUE_SIZE] = p;

back = ( back + 1 ) % QUEUE_SIZE;

numberOfItems++;

return true;

}

else

return false;

}

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" );

}

- 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.

- 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

- 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

void 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/

- 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

- In a directed graph or digraph, each edge has a specific direction.
- Edges with direction sometimes are called arcs
- Analogy: airline flights between airports

- 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

- 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

- The System.Collections.Generic; package contains a Stack class
- Like ArrayList operations, the Stack operations operate on Object references