Chapter 15: Advanced Topics: Introducing Data Structures and Recursion Visual Basic.NET Programming: From Problem Analysis to Program Design

Chapter 15: Advanced Topics: Introducing Data Structures

and Recursion

Visual Basic .NET Programming: From Problem Analysis to Program Design

Visual Basic .NET Programming: From Problem Analysis to Program Design 2

Objectives

• Create linked lists

• Create a stack

• Create a queue

• Understand recursion

• Write recursive methods


Introducing Data Structures

• Linked list

– List of object instances that are linked together

– Objects may be added to:

• Beginning

• End

• Somewhere in between



Introducing Data Structures (continued)

• Stack

– Can be implemented as specialized case of linked list

– Objects are added and removed only at beginning of list

– Employs LIFO logic

• Last in, first out



Introducing Data Structures (continued)

• Queue

– Implemented as linked list

– Objects added at end and removed from beginning

– Employ FIFO logic

• First in, first out



Creating Linked Lists

• Node

– Each instance in linked list contains

• Data

• Reference attribute linking it to next node

• Maintain references to first and last item in list

– To facilitate access


Creating Linked Lists (continued)

• Self-referencing class

– Class that references instances of itself






Creating a Stack

• Stack can be implemented as LinkedList

– LIFO structure:

• Add and remove nodes from only beginning of Stack

– Employ inheritance to create Stack class

• As subclass of LinkedList



Exploring the FCL Stack Class

• Stores nodes as instances of Object

• Methods:

– Push

– Pop

– Peek

– ToArray


Creating a Queue

• Queue can be implemented as linked list• Objects added only at end • Removed only from beginning

– Employing FIFO logic

• Enqueue– Add object

• Dequeue– Remove object



Creating a Queue (continued)

• Placing common attributes and methods in superclass eliminates redundancy in subclasses

– Count and IsEmpty added to superclass


Exploring the FCL Queue class

• Queue class

– Stores nodes as instances of Object

• Methods:

– Enqueue

– Dequeue

– Peek

– ToArray


Programming Example: Reservation Application

• Implements reservation system

• Reservation class methods:

– MakeReservation

– CancelReservation

– ListReservations



Understanding Recursion

• Programming technique in which method calls itself

• For some problems recursive approach leads to simple and elegant solution

• Recursive problem-solving approach– Divides complex problem into successively

smaller but similar subproblems

– Solves each subproblem

– Assembles result


Example 15-8: Using a Recursive Method to Simulate

Opening Boxes

Module OpenBoxesRecursively

Sub Main()

'open largest box (size 10)

OpenBox(10)

System.Console.WriteLine(”Done”)

End Sub



Opening Boxes (continued)Sub OpenBox(ByVal boxSize As Integer)

If boxSize = 0 Then

System.Console.WriteLine(”No more boxes”)

Else

System.Console.WriteLine(”Box “ & boxSize & _

“ opened”)

OpenBox(boxSize - 1)

End If



(Continued)



Opening Boxes (continued)

• Recursive algorithm must have stopping point

– Called base case

– When encountered, recursion stops




• Each time recursive method calls itself

– Fresh copy of the method created

– Each copy has own set of values and parameters

– Remains unfinished until base case is recognized




• Upon each return

– Execution resumes within that copy at line of code immediately following recursive call

• Recursion is similar to iteration

– Any problem that can be solved iteratively can also be solved recursively, and vice versa

– Recursive solutions are less efficient


Writing Recursive Methods

• Write recursive method:

– Must think recursively

– Think of problem in terms of series of successively smaller but virtually identical subproblems

– Smallest subproblem must be one that can be solved directly


Computing Factorials

• Classic example of recursion involves computing factorials

• Definition:

– n! = n * (n – 1) * (n – 2) * . . . * 1, where n is a positive integer

– 0! = 1

• Thinking recursively:

– 4! can be defined as 4 * 3!


Computing Factorials (continued)

• Calculating factorials can produce a number that is too large to be represented in memory space allocated to a particular variable

– 12! is largest factorial that can be computed using Integer data type to hold result





(Continued)


Displaying a Directory Tree

• Generate and display tree containing directories and subdirectories on hard drive

• Depending on size of your hard drive and speed of your computer

– Initially creating directory tree may take a few minutes



Sorting an Array

• Recursive methods are frequently used for array processing

• Quicksort

– Recursive technique for sorting one-dimensional array

– Begins by selecting array element to serve as pivot


Sorting an Array (continued)

• Quicksort (continued)

– Position pivot such that

• All array elements to right are greater than or equal to pivot

• All array elements to left are less than or equal to pivot

– Elements to right and left of pivot form subarrays

• Sort them using Quicksort


Programming Example: Towers of Hanoi

• Classic computer science problem

• Priests in Far Eastern temple were given task of moving stack of 64 disks from one pole to another

• Each disk was slightly different size

– Disks were arranged on pole from top to bottom in order of increasing size

– Intermediate pole also available to hold disks


Programming Example: Towers of Hanoi (continued)

• Priests were to move all 64 disks to third pole using the following rules:

– Only one disk can be moved at a time

– Removed disk must be placed on one of other poles

– Under no circumstance may larger disk be placed upon smaller disk

• Priests were told that world would end when they completed their task




Programming Example: Towers of Hanoi (continued)

• Recursive algorithm:

– Move top n-1 disks from pole 1 to pole 2, using pole 3 to temporarily hold disks

– Move bottom (nth) disk from pole 1 to pole 3

– Move n-1 disks on pole 2 to pole 3, using pole 1 to temporarily hold disks

• Number of moves required to move the disks is 264-1


Summary

• Linked list

– List of object instances that are linked together

– Each instance is called a node

• Stack

– Can be implemented as special form of LinkedList

– LIFO structure

– FCL provides Stack class


Summary (continued)

• Queue – Implemented as linked list with objects added at

end and removed from beginning

– Employ FIFO logic

– FCL includes Queue class

• Recursive problem-solving approach – Divides problem into series of smaller problems

– Solves each subproblem

– Assembles result

Documents

Chapter 15: Advanced Topics: Introducing Data Structures and Recursion Visual Basic.NET Programming: From Problem Analysis to Program Design