stacks queues introduction to trees. stacks an everyday example your boss keeps bringing you...

StacksQueues

Introduction to Trees

Stacks

An Everyday Example

• Your boss keeps bringing you important items to deal with and keeps saying:

“Put that last ‘rush’ item I gave you on hold; this is more important, so rush it out first.”

We’ll end up doing the last item first(last in, first out).

In general...

• A stack can keep track of, “Where was I?”– Activation Stack– Compilers

endifendif

• Cafeterias use stacks: Plates, trays...

The Stack

Push Pop

Idea: a “Last In, First Out” (LIFO) data structure

Behaviors:• Push: Add to top of stack• Pop: Remove from top of stack (and return that

top value)• Top: Return topmost item (but leave it on the

stack)• Is_Full: is it full?• Is_Empty: is it empty?• Initialize: empty stack

Properties

The Stack as a Logical Data Structure

• The stack is an idea• It implies a set of logical behaviors• It can be implemented various ways– Using a linked list or a tree or an array

• In this example, we’ll focus on dynamic implementations using dynamic data...

Stacks:Dynamic Implementation

A linked list with restricted set of operations to change its state: only modified from one end

Defining the Node Type

This is the simple data structure we will use in the following example.

Node definesa record data isoftype Num next isoftype Ptr toa Nodeendrecord // Node

Recall that the same code (with some small modifications) will work with more complex data structures such as is shown here:

Student_Rec definesa Record Name isoftype String SSN isoftype String GPA isoftype Numendrecord // Student_Rec

Node definesa Record data isoftype Student_Rec next isoftype Ptr toa Nodeendrecord // Node

Complex Node Definition

procedure Push (value isoftype in Num, top isoftype in/out Ptr toa Node)// Purpose: push one value onto stack // Pre: top points to NIL-terminated list// Post: the list has one node added

procedure Pop (value isoftype out Num, top isoftype in/out Ptr toa Node, result isoftype out Boolean)// Pop a value off stack; if empty, result// contains FALSE (value will be undefined)// Pre: top points to a NIL-terminated list// Post: list has one fewer, value is old data

Application Programmer Interface

• Create new node• Add it to the front

Procedure Push (value isoftype in Num, top isoftype in/out Ptr toa Node) // Push one value onto stack

temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- top top <- tempendprocedure // Push

• Capture the first value (to return)• Remove the first node (move top to next)

value = 4

value (4) is returned

procedure Pop (value isoftype out Num, top isoftype in/out Ptr toa Node, result isoftype out Boolean) // Pop an element off the stack

if(top = NIL) then result <- FALSE else result <- TRUE value <- top^.data top <- top^.next endifendprocedure // Pop

Student’s Choice?

DoTrace

SkipTrace

Algorithm Fragment.top isoftype Ptr toa NodeOK isoftype BooleanN isoftype Numtop <- NILPush(42, top)Push(2, top)Pop(N, top, OK)if(OK) then print(N)endifPush(7, top)Pop(N, top, OK)Pop(N, top, OK).

.top isoftype Ptr toa NodeOK isoftype BooleanN isoftype Numtop <- NILPush(42, top)Push(2, top)Pop(N, top, OK)if(OK) then print(N)endifPush(7, top)Pop(N, top, OK)Pop(N, top, OK).

OK =N =

top.top isoftype Ptr toa NodeOK isoftype BooleanN isoftype Numtop <- NILPush(42, top)Push(2, top)Pop(N, top, OK)if(OK) then print(N)endifPush(7, top)Pop(N, top, OK)Pop(N, top, OK).

OK =N =

topProcedure Push (value isoftype in Num, top isoftype in/out Ptr toa Node) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- top top <- tempendprocedure temp =

OK =N =

topProcedure Push (value isoftype in Num, top isoftype in/out Ptr toa Node) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- top top <- tempendprocedure

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

Procedure Push (value isoftype in Num, top isoftype in/out Ptr toa Node) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- top top <- tempendprocedure

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

temp =

OK =N =

Procedure Pop value isoftype out Num, top isoftype in/out Ptr toa Node, result isoftype out Boolean) if(top = NIL) then result <- FALSE else result <- TRUE value <- top^.data top <- top^.next endifendprocedure

value =result =

OK =N =

value =result =

OK =N =

value =result = T

OK =N =

value = 2result = T

OK =N =

value = 2result = T

OK =N =

value = 2result = T

OK = TN = 2

OK = TN = 7

OK = TN = 42

Summary: Stack

• Allow us to model “last-in, first-out” (LIFO) behavior

• Can be implemented using different data types

• Behavior is important (and defines a Stack)– Push to the front– Pop from the front– (from the same end)

Questions?

Queues

Some Examples

• Waiting in line– At the grocery store– At the movies– Printer queue

• Ordering items– Bills to pay–Making pizzas

• We can use a queue to model each of these.

The Queue

Enqueue

Dequeue

Idea: a “First In, First Out” (FIFO) data structure

Behaviors:• Enqueue: Add to end of queue• Dequeue: Remove from front of queue (and

return that front value)• Front: Return front-most item (but leave it in the

queue)• Is_Full: is it full?• Is_Empty: is it empty?• Initialize: empty queue

Properties of Queues

The Queue as a Logical Data Structure

• The queue is an idea• It implies a set of logical behaviors• It can be implemented various ways– Using a linked list or a tree or an array

• In this example, we’ll focus on dynamic implementations using dynamic data...

Queues:Dynamic Implementation

A linked list with restricted set of operations to change its state: only modified by adding to one end and deleting from the other.

4 17 42

tailhead

Queue Record Definition

Queue definesa record head, tail isoftype Ptr toa Nodeendrecord // Queue

Defining the Node Type

This is the simple data structure we will use in the following example.

Node definesa record data isoftype Num next isoftype Ptr toa Nodeendrecord // Node

Recall that the same code (with some small modifications) will work with more complex data structures such as is shown here:

Student_Rec definesa Record Name isoftype String SSN isoftype String GPA isoftype Numendrecord // Student_Rec

Node definesa Record data isoftype Student_Rec next isoftype Ptr toa Nodeendrecord // Node

Complex Node Definition

Application Programmer Interfaceprocedure Enqueue (value isoftype in Num, Q isoftype in/out Queue)// Pre: Q is initialized// Purpose: Add a value to the tail// Post: Q has new element at tail

procedure Dequeue (value isoftype out Num, Q isoftype in/out Queue, result isoftype out Boolean)// Pre: Q is initialized// Purpose: Remove first value from Q and// return it via ‘value’ OR indicate// that Q is empty via ‘result’ // Post: element that was at head has been// removed OR (result = FALSE)

Enqueue

• Create a new node with data• Add it to the end– Update pointers as needed

tailhead

Enqueue

tailhead42

Enqueue

tailhead42

Enqueue

tailhead

procedure Enqueue (value isoftype in Num, Q isoftype in/out Queue) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- NIL if(Q.tail = NIL) then // was empty Q.tail <- temp Q.head <- temp else // was not empty Q.tail^.next <- temp Q.tail <- temp endifendprocedure // Enqueue

Dequeue

• Capture the first value (to return)• Remove the first node (move head to next)

Dequeue

value = 4

Dequeue

value = 4

Dequeue

value (4) is returned

procedure Dequeue (value iot out Num, Q iot in/out Queue, result iot out Boolean) if(Q.head = NIL) then result <- FALSE else result <- TRUE value <- Q.head^.data Q.head <- Q.head^.next if(Q.head = NIL) then Q.tail <- NIL endif endifendprocedure // Dequeue

Initializing the Queue

procedure QInit (Q isoftype out Queue)// Initializes the Q head and tail// to point to nil, setting the Q to// be empty Q.head <- NIL Q.tail <- NILendprocedure // QInit

Student’s Choice

DoTrace

SkipTrace

Algorithm Fragment.myQ isoftype QueueOK isoftype BooleanN isoftype Num

Qinit(myQ)Enqueue(42, myQ)Enqueue(2, myQ)Dequeue(N, myQ, OK)Enqueue(7, myQ)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)if(NOT OK) then print(“myQ is empty”)endif.

.myQ isoftype QueueOK isoftype BooleanN isoftype NumQinit(myQ)Enqueue(42, myQ)Enqueue(2, myQ)Dequeue(N, myQ, OK)Enqueue(7, myQ)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)if(NOT OK) then print(“myQ is empty”)endif.

headtail

.myQ isoftype QueueOK isoftype BooleanN isoftype NumQinit(myQ)Enqueue(42, myQ)Enqueue(2, myQ)Dequeue(N, myQ, OK)Enqueue(7, myQ)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)if(NOT OK) then print(“myQ is empty”)endif. OK N

procedure Qinit (Q isoftype out Queue) Q.head <- NIL Q.tail <- NILendprocedure

procedure Enqueue (value isoftype in Num, Q isoftype in/out Queue) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- NIL if(Q.tail = NIL) then Q.tail <- temp Q.head <- temp else Q.tail^.next <- temp Q.tail <- temp endifendprocedure

procedure Enqueue (value isoftype in Num, Q isoftype in/out Queue) temp isoftype Ptr toa Node temp <- new(Node) temp^.data <- value temp^.next <- NIL if(Q.tail = NIL) then Q.tail <- temp Q.head <- temp else Q.tail^.next <- temp Q.tail <- temp endifendprocedure temp

procedure Dequeue (value isoftype out Num, Q isoftype in/out Queue, result isoftype out Boolean) if(Q.head = NIL) then result <- FALSE else result <- TRUE value <- Q.head^.data Q.head <- Q.head^.next if(Q.head = NIL) then Q.tail <- NIL endif endifendprocedure

.myQ isoftype QueueOK isoftype BooleanN isoftype NumQinit(myQ)Enqueue(42, myQ)Enqueue(2, myQ)Dequeue(N, myQ, OK)Enqueue(7, myQ)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)Dequeue(N, myQ, OK)if(NOT OK) then print(“myQ is empty”)endif. OK N OK T N 42

OK T N 42

Peeking backat calling program.

OK N OK N

OK N OK T N 42

OK N OK T N 2

OK N OK T N 7

OK F N OK N 7

myQ is empty

OK F N OK N 7

myQ is empty

OK F N OK N 7

myQ is empty

Summary: Queues

• Allow us to model “first-in, first-out” (FIFO) behavior

• Can be implemented using different data types

• Behavior is important (and defines a Queue)– Enqueue to end– Dequeue from front– (or vice-versa – just do at opposite ends)

Questions?

Introduction to Trees

A non-linear, hierarchical collection with a “one to many” relationships

Visual Representation of a Tree

Trees allow each node to have multiple successors

Parent

Tree Terminology

Parent

Tree Terminology

• The first node is called the root.

• Successors are called children

• A parent node points to a child node.

• Nodes with no children are called leaves.

Binary Trees

Binary trees can have at most two successors.

Binary Tree ExampleNo imposed ordering.

105 111312

Structure of a Binary Tree Node

<Type Name> definesa Record data isoftype <type> left_child isoftype Ptr toa <Type Name> right_child isoftype Ptr toa <Type Name>endrecord

left_child right_child

Example Definition: Binary Tree Node

Tree_Node definesa Record data isoftype Num left_child isoftype Ptr toa Tree_Node right_child isoftype Ptr toa Tree_Nodeendrecord // Tree_Node

root 34

Binary Search Trees

For each node, the value stored in it is greater than the value in every node in the left sub-tree and less than the value in every node in the right sub-tree

Can a Tree be a BST and not a BST?

1100Bob

9494Sal

2102Abe

882Zak

904Ned

7856Tom

1234Ava

Node Depth in a Tree• Measures how far down a node is in the tree.• How many “ancestor” nodes “live above” the

Balanced TreesRoughly symmetrical• There is a difference of a most one level of depth

among the various leaves

Balanced Not Balanced

Summary• Trees allow us to create nonlinear collections

• Binary Trees have at most two successors (children)

• Binary Search Trees impose structure– Every node’s value is greater than all the

values in its left sub-tree– Every node’s value is less than all the

values in its right sub-tree

Questions?

stacks queues introduction to trees. stacks an everyday example your boss keeps bringing you...

Documents