This presentation is the property of its rightful owner.
1 / 68

# Data Structures Part 2 PowerPoint PPT Presentation

Data Structures Part 2. Stacks, Queues, Trees, and Graphs. Briana B. Morrison CSE 1302C Spring 2010. Topics. Stacks Queues Trees and Graphs. Classic Data Structures. Now we'll examine some classic data structures Classic linear data structures include queues and stacks

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

### Topics

• Stacks

• Queues

• Trees and Graphs

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

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

push

pop

### Stacks

• Stacks often are drawn vertically:

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

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

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

### Array Representing a Stack

• There are three items on the stack:

### Stack after Inserting Player (6, Steve, NFL )

• Now there are four items on the stack:

### Our Stack After Popping Once

• Now there are three items on the stack. Player ( 6, Steve, NFL ) is not on the stack.

### 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 inttop, representing the top of the stack.

public class ArrayStack

{

private static final int STACK_SIZE = 100;

private Player [] stack;

private int top;

….

}

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

}

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

{

return ( top == -1 );

}

public boolisFull( )

{

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

}

### toString Method for our Stack

public String toString( )

{

String stackString = "";

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

stackString += ( i + ": "

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

return stackString;

}

### push Method for our Stack

public boolean push( Player p )

{

if ( !isFull( ) )

{

stack[++top] = p;

return true;

}

else

return false;

}

### pop Method for our Stack

public Player pop

{

if ( !isEmpty( ) )

return ( stack[top--] );

else

throw new DSException

( "Stack empty: cannot pop" );

}

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

dequeue

enqueue

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

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

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

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

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

### A Linked List Implementing a Queue

• 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

tail

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

• Our original list:

7

Sarah

Mario

5

Ajay

Sonic

8

Gino

Diablo

2

Jin

Golf

null

tail

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

7

Sarah

Mario

8

Gino

Diablo

5

Ajay

Sonic

2

Jin

Golf

null

tail

6

Steve

NFL

null

pn

### Inserting in a Linked List Representing a Queue

• 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

tail

### Inserting in a Linked List Representing a Queue

• Step 3: Update tail:

tail = tail.getNext( );

7

Sarah

Mario

5

Ajay

Sonic

8

Gino

Diablo

6

Steve

NFL

2

Jin

Golf

null

tail

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

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

### Queue after Inserting First 5 Elements

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

### Queue after Dequeueing Once

• Element at index 0 is no longer usable.

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

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

### Empty Queue

• When the queue is empty, we also have the same relationship between front and back!

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

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

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

}

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

}

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

{

return ( numberOfItems == 0 );

}

public booleanisFull( )

{

return ( numberOfItems == QUEUE_SIZE );

}

### toString Method for our Queue

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;

}

### enqueue Method for our Queue

public booleanenqueue( Player p )

{

if ( !isFull( ) )

{

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

back = ( back + 1 ) % QUEUE_SIZE;

numberOfItems++;

return true;

}

else

return false;

}

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

}

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

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

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

### Visiting Every Node

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/

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

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

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

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

### Stacks

• The System.Collections.Generic; package contains a Stack class

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