One-Dimensional Arrays, Searching

About This Presentation

Title:

One-Dimensional Arrays, Searching

Description:

Array Data Structures & Algorithms Lecture 5 One-Dimensional Arrays, Searching & Sorting ... – PowerPoint PPT presentation

Number of Views:315

Avg rating:3.0/5.0

Slides: 109

Provided by: DrRo123

Category:

more less

Transcript and Presenter's Notes

Title: One-Dimensional Arrays, Searching

1
Array Data Structures Algorithms

Lecture 5
One-Dimensional Arrays, Searching Sorting

2
Array Data Structures Algorithms

Concepts of Data Collections
Arrays in C
Syntax
Usage
Array based algorithms

3
5A Concepts of Data Collections

Sets, Lists, Vectors, Matrices and beyond

4
Sets Lists

The human language concept of a collection of
items is expressed mathematically using Sets
Sets are not specifically structured, but
structure may be imposed on them
Sets may be very expressive but not always easily
represented
Example The set of all human emotions.
Lists are representations of sets that simply
list all of the items in the set
Lists may be ordered or unordered.
Some useful lists include data values and the
concept of position within the list.
Example representations 0, 5, -2, 4
TOM, DICK

First Second
5
Vectors, Matrices and beyond

Many examples of lists arise in mathematics and
they provide a natural basis for developing
programming syntax and grammar
Vectors are objects that express the notion of
direction and size (magnitude)
The 3-dimensional distance vector D has
components Dx, Dy, Dz along the respective x,
y and z axes, with magnitude D
sqrt(Dx2Dy2Dz2)
We use descriptive language terminology such as
The xth component of D
... Or, D-sub-x

6
Vectors, Matrices and beyond

Higher dimensional objects are often needed to
represent lists of lists.
Matrices are one example that sometimes can be
represented in tabular form
2-dimensional tables (row, column)
3- and higher are hard to visualize, but are
meaningful
Beyond this, mathematics works with objects
called tensors and groups (and other things), and
expresses the access to object members (data
values) using properties and indices based on
topologies (loosely put, shape structures)

7
Vectors, Matrices and beyond

In this course we focus on an introduction to the
basic properties and algorithms associated with
one-dimensional arrays, or vectors
These objects are mathematically defined as
ordered, structured lists
The ordering derives from the property that each
element of the list exists at a specific position
Enumerated starting at 0 and incrementing by 1 to
a maximum value
The structure determines the mechanism and method
of access to the list and its member elements

8
5B Arrays in C

Syntax
Memory structure
Usage
Functions

9
Arrays in C

Syntax
How to declare and reference 1D arrays using
subscript notation
Memory structure
How is RAM allocated the meaning of direct
access through subscripting
Usage
Some simple illustrative examples
Functions
How to deal with arrays as function arguments

10
Arrays in C - Syntax

Consider the array declarations
int StudentID 1000 float Mark
1000 char Name 30
Each of the declarations defines a storage
container for a specific maximum number of
elements
Up to 1000 Student (integer) ID values
Up to 1000 (real) Marks
A Name of up to 30 characters

11
Arrays in C - Syntax

Each array is referred to by its declared name
float A 100 ... where A refers to the
entire collection of 100 storages
On the other hand, each separate element of A is
referenced using the subscript notation
A0 12.34 / assign 12.34 to the first
element / / NOTE subscripts always
start from 0 /
AK 0.0 / assign 0 to the (K1)th
element /

Note Although a bit clumsy in human natural
language, we can change our use of language so
that AK always refers to the Kth element (not
K1), always starting from 0 as the 0th element.
12
Arrays in C - Syntax

It is not necessary to initialize or reference
all elements of an array in a program
Unlike scalar variables declared as primitive
data types, these uninitialized, non-referenced
array elements are not flagged as warnings by the
compiler
There are good reasons to declare arrays of
larger size than might be required in a
particular execution run of a program
At the outset, design the program to accommodate
various sizes of data sets (usually acquired as
input), up to a declared maximum size
This avoids the need to modify and recompile the
program each time it is used.

13
Arrays in C - Syntax
define directives are normally located at the
beginning of the program source code, after
include directives, and before function
prototypes and the main function. By using the
defined symbol MAX_SIZE, changes to SID and Mark
array sizes can be accomplished by simply
changing the value assigned to MAX_SIZE and
recompiling.

This is a good time to introduce another compiler
pre-processor directive, define
define is used to define constant expression
symbols in C programs. The value of such symbols
is that they localize positions of program
modification.
Example
define MAX_SIZE 1000
int main ( ) int SID MAX_SIZE
float Mark MAX_SIZE .....

14
Arrays in C Memory structure

Now consider the declaration
int A 9
The entire allocation unitis called A the
array name
There must be 9 integersized allocations in RAM
Each element is locatedcontiguously (in
sequenceand touching)

RAM
A
A0 A8
15
Arrays in C Memory structure
The sizeof, operator is a compile-time operator
(not an executable instruction or operator) that
determines the RAM storage size allocated to a
data structure. When sizeof is applied to a
primitive data type, it provides the size of
allocated storage, in bytes. Try running a
program with statements such as printf( The
size of int is d bytes\n, sizeof int )

Arrays are often calleddirect access
storagecontainers
The reference to AKis translated by
thecompiler to
First, calculate the relative address offsetK
sizeof int
Second, add RAO tobase address of A, or
simplyA0
AK A0 Ksizeof int

RAM
sizeof int
A0 A K
0 1 K
RAO
Direct Access Since the cost of the address
computation is always the same (constant) and it
provides the actual RAM address location where
the data is stored.
16
Arrays in C Usage

Referencing arrays is straightforward using the
subscript notation
B A 5 / assign 6th element of A to B /
A J lt A K / relational expression /
B 0.5( AJ AJ-1 ) / finite
difference /
printf( d d d\n, A0, Amid, AN-1 )
scanf ( dlflf, N, RK, R ) / Note /

17
Arrays in C Average vs Median

Problem Input N real numbers and find their
average and median.
Assume the values are already sorted from lowest
to highest
Assume no more than 1000 values will be inputted
Solution
Declarations
float X 1000, Sum, Ave, Median int N,
Mid

18
Arrays in C Average vs Median

Declarations
float A 1000, Sum 0.0, Ave, Median
int N, Mid, K
Input Data
printf( Enter number of values in list )
scanf( d, N )
/ Enter all real values into array X /
for( K0 K lt N K ) scanf( f,
AK ) / NOTE must be used /
Sum AK

19
Arrays in C Average vs Median

Compute Average and Median
Ave Sum / (float) N / real division
/
Mid N / 2 / (integer) midpoint of
list / Median A Mid
Report results
printf( Average , Ave ) printf( Median
f\n, Median )

20
Arrays in C Related arrays

Problem Obtain student marks from testing and
store the marks along with ID numbers
Assume marks are float and IDs are int data types
Solution Related arrays
Define two arrays, one for IDs and one for marks
int SID 100 float Mark 100
Coordinate input of data (maintain relationships)
for( K 0 K lt N K ) scanf(
df, SIDK, MarkK )

21
Arrays in C Functions
U

Passing arrays as parameters in functions
requires some care and some understanding. We
begin with an example.
Calculate the dot product of two 3-vectors U and
V.
Components U0, U1, U2 V0,
V1, V2
Mathematics The dot product is defined as
DotProd( U, V ) U0V0 U1V1
U2V2
Since the dot product operation is required
often, it would make a useful function.

V
U . V
22
Arrays in C Functions

Solution function
double DotProd3 ( double U3, double V3 )
return U0 V0 U1 V1 U2
V2
Note the arguments which specify that arrays of
type double with exactly three (3) elements will
be passed.
Note that the limitation to 3 elements is
reflected in the design of the function name
DotProd3

23
Arrays in C Functions

Extend this to dot product of N-dimensional
vectors
double DotProdN ( double U , double V , int
N ) double DPN 0.0 int K
for( K 0 K lt N K ) DPN UK VK
return DPN
Note the array arguments do not specify a maximum
array size.
This provides flexibility of design since now the
function can handle any value of N. It is up to
the programmer to ensure that the actual input
arrays and N conform to the assumptions.

24
Arrays in C Functions

An alternative to the same code is to use pointer
references
double DotProdN ( double U, double V, int N
) double DPN 0.0 int K
for( K 0 K lt N K ) DPN UK VK
return DPN
Note the array arguments are now expressed as
pointer references.
This maintains the same flexibility as previously.

25
Arrays in C Functions
Pointers are not the same as ints ! If A is an
int (say, 5), then A always evaluates to the
next (or successor) value in sequence (ie.
6). On the other hand, if P is a pointer (say,
int , with value AK), then P evaluates to
the next (or successor) value in sequence, which
is usually the next element of an array (ie.
AK1).

A final alternative to the same code is to use
pointer references altogether
double DotProdN ( double U, double V, int N
) double DPN 0.0 int K
for( K 0 K lt N K, U, V ) DPN U
V return DPN
The U and V variables are address pointers to the
array components.
U and V perform the action of updating the
pointers by an amount equal to the size of the
array data type (in this case double is usually 8
bytes), thus pointing to the next array component
in sequence.

26
Arrays in C Functions

The previous examples have illustrated the
various ways that are used to pass array
arguments to functions.
double DotProd3 ( double U3, double V3 )
double DotProdN ( double U , double V , int N
)
double DotProdN ( double U, double V, int N
)
There are important differences
When the size of the array is specified
explicitly (eg. double U3) , some C compilers
will allocate storage space for all array
elements within the function stack frame
If arrays are declared within the function body,
they are almost always allocated within the stack
frame
When the array size is not stated explicitly, a
pointer to the array is allocated (much smaller
in size than the entire array)

27
Arrays in C Functions

C compilers may perform code and storage
optimization
Create the most efficient executable code
Create the most efficient use of RAM storage
By allocating array storage within stack frames,
a significant amount of wasted space occurs due
to avoidable duplication of storage allocations
It also follows that a wastage of time occurs
since it is necessary to copy data from arrays
declared in the calling point code to arrays
declared in the called point.
Pointers solve most of these problems (with a
small, but acceptable, increase in processing
time)
Optimization is a difficult problem and is still
the subject of much research

Theoretical
28
5C Array Based Algorithms

Searching
Sorting

Very practical !
29
Array Based Algorithms

Searching
How to locate items in a list
Simplicity versus speed and list properties
Sorting
Putting list elements in order by relative value
Promoting efficient search

30
Search Algorithms

Searching is a fundamentally important part of
working with arrays
Example Given a student ID number, what is the
Mark they obtained on the test? Do this for all
students who enquire.
Constructing a good, efficient algorithm to
perform the search is dependent on whether the
IDs are in random order or sorted.
Random order use sequential search
Sorted order use divide-and-conquer approach

31
Search Algorithms - Random
PROBLEM 1 No guarantee that rand() will
produce a result and exit the for loop,
especially if the item does not exist. PROBLEM
2 It is possible that an array element position
will be accessed that has not had data stored
(will stop the program as an error
uninitialized data access violation).

If a list is stored in random order a possible
search technique is to look at the list elements
in random order search
int srchID, K
printf( Enter your SID ) scanf( d,
srchID )
for( Krand() N srchID ! SID K
Krand() N )
printf( SID d, Mark f\n, SIDK,
MarkK )

32
Search Algorithms - Linear
The Linear Search algorithm starts at the
beginning of the list and proceeds in sequence
K 0 / start at beginning of list / do
/ search the list / if ( srchID SID K
) break / exit loop if found / K
/ move to next position / while ( K lt N )
/ stop at end of list / These can be combined
in a single for structure as shown below.

Note that the loop is controlled by two
conditions
KltN
This demands that K be initialized at the
beginning of the list (K0)
It also ensures that traversal of the list stops
at the end of the logical list (since the actual
array size may be larger)
(2) srchID ! SIDK
This ensures that as soon as the value is found,
the loop is exited immediately, thereby avoiding
unnecessary work

If a list is stored in random order a better
search technique is to look at the list elements
in order, from the beginning of the list until
the element is found or the list elements are
exhausted
int srchID, K, N 100 / Assume 100
elements /
printf( Enter your SID ) scanf( d,
srchID )
/ Perform the search / for( K0 KltN
srchID ! SID K K )
if( KltN ) printf( SID d, Mark
f\n, SIDK, MarkK )

33
Search Algorithms - Linear

Since this search approach considers each element
of the list in sequence, it is called Sequential,
or Linear, search.
In any situation where the list being searched
does not contain the value being searched for,
all N elements must be considered
This is called the worst case scenario
However, when the element will be found ...
The best case occurs when we actually find the
value looked for in the first position considered
The average case refers to the statistical
average obtained over many searches of the list
This is clearly just N/2 elements considered

The term Linear derives from the fact that the
actual runtime performance of the algorithm, in
terms of numbers of distinct CPU operations, is
expressed as a formula like T A N B
This is just the equation for a line (recall
y mx c)
34
Search Algorithms - Linear
To appreciate the improvement, consider cases
where srchID will not be located in SID. For a
statistical spread of srchID values (some big,
some small) on average, only N/2 comparisons are
required to eliminate the need to search further.
The previous algorithm always requires N
comparisons. The complexity is still O(N),
however.

In cases where the list is sorted, the search
algorithm can be improved upon ....
Assume that SID is sorted in ascending order
/ Perform the search / for( K0 KltN
srchID lt SID K K )
if( KltN srchID SID K )
printf( SID d, Mark f\n, SIDK, MarkK
)
Always examine code carefully to ensure that the
logic properly accounts for all circumstances
that can arise, both positive and negative.

35
Search Algorithms - Efficiency

The time complexity (efficiency, or cost) of an
algorithm is important in programming design
Algorithmic efficiencies can be divided into
several categories, depending on various
properties of the problem under consideration
NP-complete (computable in finite time)
NP-hard (computable in principle, but requires
special care and may not actually execute in
reasonable time)
NP-incomplete (not guaranteed to execute in
finite time, contains unknowable aspects)
NP refers to the way that an algorithm performs
and is expressed as a polynomial which may also
include functions (such as exponential or
logarithm)

36
Search Algorithms - Efficiency

Many problems are characterized by parameters
that describe the nature of the data set, or the
number of operations that must be performed to
complete the algorithm
Search problems assume a data set of size N
For the Sequential Search algorithm (over N
values)
K 0 1 storedo if ( Value
SearchValue ) break 2 fetch, 1 compare, 1
branch K 1 fetch, 1 increment, 1
store while ( K lt N ) 2 fetch, 1
compare, 1 branch/ Report result / R
(constant) operations
/ In the worst case, all N loops are completed
/
Cost N ( 5 fetch 1 store 1 increment
2 compare 2 branch ) R 1 store

37
Search Algorithms - Efficiency
The Big O notation in this case is expressed
as Time Complexity O( NK ) for
F(N) Alternatively, we say the Order of F(N)
is NK Note that we ignore the leading
coefficient (aK) of NK, regardless of its
magnitude.

Assume that the behaviour of an algorithm (ie.
how long it takes to execute) is described by a
function F(N) that counts the number of
operations required to complete the algorithm.
Consider the polynomial in N
F(N) aK NK aK-1 NK-1 ... a1 N a0
...
As N increases to very large values, the smallest
terms, those with smaller powers (exponent) of N
become less relevant (regardless of the size of
coefficient aK)
Rather than using complicated polynomial formulas
to describe algorithmic time cost, a more
convenient notation has been developed the BIG
O (Order) notation.

38
Search Algorithms - Binary

Let us now consider a list V of N values where
the elements VK are sorted in ascending order
(from smallest to largest)
V0 lt V1 lt ..... lt VN-2 lt VN-1
Problem Find if/where the search value VS is in
V
We develop the Binary Search algorithm
Our design technique is based on the principle of
Divide and Conquer
Also called Binary Subdivision

39
Search Algorithms - Binary

Our strategy involves the idea of sub-list. A
sub-list is simply a smaller part of a list.
By dividing a list into two sub-lists (where each
sub-list contains contiguous values that are
sorted) it is possible to quickly eliminate one
of the sub-lists with a single comparison.
Thereafter, we focus attention on the remaining
sub-list but, we reapply the same divide and
conquer technique.

40
Search Algorithms - Binary
ignore

We assume that all data has been inputted to
array V, N has been initialized with the number
of input values, and the search value VS has been
inputted.
We use the following declarations
float V 10000 , VS int Lo, Hi, Mid, N
Binary Search algorithm uses the variables Lo and
Hi as array subscripts
Lo refers to the first value position in a
sub-list
Hi refers to the last value position in a
sub-list
Mid is used as the midpoint subscript Mid
(LoHi)/2

ignore
41
Search Algorithms - Binary

Binary Search algorithm
Lo 0 Hi N-1 / Use full list as
sub-list /
do
Mid ( Lo Hi ) / 2 / int
division /
if( VS VMid ) break
if( VS gt VMid ) Lo Mid 1
else Hi Mid 1
while ( Lo lt Hi )
printf( Search value f , VS ) if (
VS VMid ) printf( found at
position d\n, Mid ) else printf(
not found\n )

VS
VS
VS
?????
42
Search Algorithms - Binary

To understand the complexity assume a data set of
256 values. We consider the worst case scenario.
Size of data set Step 256 1
128 2
64 3
32 4
16 5
8 6
4 7
2 8
1 9
Once we split the sub-list to size 1 we clearly
determine that the list cannot contain the search
value.

N 256 28, so it has taken 81 9 steps to
prove that VS does not exist in V. In general,
for a list of size N 2K, it takes K1 steps, or
O( log2 N )
43
Search Algorithms - Binary

In general, for a list of size N 2K, it takes
K1 steps, or O( log2 N ) time complexity
K is just the logarithm (base-2) of N
The efficiency of the Binary Search algorithm is
logarithmic, or O( log N ).
Some people prefer to say O ( log2 N), but they
are mathematically identical

44
Search Algorithms

The relative efficiencies, or complexities, of
the various search algorithms is clearly
established when N is large, and for the worst
case scenarios.
Random O( gtN ? )
Sequential (Linear) O( N )
Divide Conquer (Binary) O( log N )
In the best case, any search algorithm may be
successful after only one (1) probe
Usually, one is interested in worst case and
average case in choosing an algorithm.

45
Sorting Algorithms
.... Putting things in order ....
.... order things Putting in ....
46
Sorting Algorithms

From our discussion of binary search we
understand the need for the data to be ordered
within lists in order to promote fast searching
using Binary Search
It is also important to understand that not every
list should be sorted study each case carefully
Sorting algorithms are designed to perform the
ordering required
There are literally hundreds of specialized
sorting algorithms, with varying efficiencies
We will focus on a sorting algorithm called
Selection Sort

47
Sorting Algorithms - Selection

Selection Sort relies on being able to find the
largest (or smallest) element in a sublist
Each time the proper value is found, it is
exchanged with the element at the end of the
sublist
We re-apply this technique by shrinking the size
of the sublist, until there is no remaining
sublist (or a sublist of size 1 element which
is already sorted).
We consider the example ..........

48
Sorting Algorithms - Selection
1
2
3
4
49
Sorting Algorithms - Selection
5
8
6
7
50
Sorting Algorithms - Selection

From the example we note that the final step 8 is
not actually required, since a sub-list of one
(1) element is automatically sorted (by
definition).
Hence, it took 7 steps to complete the sort. In
general, for a list of size N elements, it takes
N-1 steps.
Each step consists of two parts
First, search an unordered sub-list for the
largest element
The size of the sub-list is N-K for step K
(starting from K0)
Second, exchange (swap) the largest element with
the last element in the sub-list
Upon completion of each step it should be noted
that the sorted sub-list grows by one element
while the unsorted sub-list shrinks by one
element.

51
Sorting Algorithms - Selection

Start with a sub-list of N unsorted values, and a
sub-list of 0 sorted values.
The unsorted sub-list has subscripts in the
subrange 0..N-1
The sorted sub-list has subscripts in the
subrange N..N which is not occupied physically
(hence, it does not exist, it is the empty set)
For K from 0 to N-1, in increments of 1, perform
Search the unordered sub-list 0..N-1-K for the
largest value and store its position P
Exchange the largest element with the last
element in the sub-list using positions P and
N-1-K.
/ The exchange adds the largest element to the
beginning of the sorted sub-list, while removing
it from the end of the unsorted sub-list /

52
Sorting Algorithms - Selection
Swapping of array elements must be done with some
care and thought. Three statements are required,
and a temporary storage variable must be used.

void SelectionSort ( double List , int N )
int J, K, P double Temp
for( J 0 J lt N-1 J )
P 0
for( K 0 K lt N - J K )
if( ListP lt ListK ) P K
Temp ListP ListP
ListN-1-J ListN-1-J Temp

Temp ListP ListN-1-J
62
1
62
56
3
2
56
62
53
Sorting Algorithms - Selection
/ Define a dswap function / void dswap (
double A, double B ) double T
T A A B B T
return

void SelectionSort ( double List , int N )
int J, K, P
double Temp
for( J 0 J lt N-1 J )
P 0
for( K 0 K lt N - J K )
if( ListP lt ListK ) P K
Temp ListP ListP
ListN-1-J ListN-1-J Temp

dswap ( ListP, ListN-1-J )
54
Sorting Algorithms - Selection

void SelectionSort ( double List , int N )
int J, K, P double Temp
for( J 0 J lt N-1 J )
P 0
for( K 0 K lt N - J K )
if( ListP lt ListK ) P K
Temp ListP ListP
ListN-1-J ListN-1-J Temp

How many operations must be performed? Sum from
J 0 to N-2 Sum from K 0 to N-1-J
Core loop logic (CoreOps) Gauss dealt with this
problem and developed several formulae which bear
his name. In this case the answer is ½ N ( N
1 ) CoreOps
55
Sorting Algorithms - Selection

The maximum number of operations required to sort
a list of N elements in ascending order is
½ N ( N 1 ) CoreOps
The CoreOps consist of several fetches, one
comparison and either 1 or 2 assignments (stores)
This is, essentially, a constant value
Thus, the time complexity of the Selection Sort
algorithm is
O( N 2 )

56
Sorting Algorithms

There are many other sorting algorithms
InsertionSort
QuickSort
MergeSort
Some of these are iterative, while others are
recursive.
A number of sorting algorithms exhibit time
complexities of O( N2 ), but some achieve better
efficiencies (eg. O( N log N ) ) under certain
circumstances.
Additional algorithms will be discussed in 60-141
and other computer science courses

57
Other Array Applications
Recommendation for Learning Some students
experience difficulties learning mathematical
concepts, from algebra to statistics.
Programming the techniques will greatly improve
understanding and help to cement the concepts
with a foundation based on application and
practice.

One-dimensional arrays are used in many fields of
science, mathematics, engineering and almost any
subject for which computational simulation is
involved
Computer Graphics and Gaming
Physics and Chemistry
Financial modeling
Business accounting
In all cases it is important to understand the
role that vectors play (conceptually and
theoretically) in addition to simply using arrays
as storage containers
Typically, mathematical properties are used to
develop algorithms and also to determine which
algorithms are the best (optimal) choice in
particular circumstances.

58
Recursive Binary Search
Example usage for calling P BinSearch( VS,
V, 0, N-1 ) if( P -1 ) printf(
Value lf not found, VS ) else
printf( Value lf found at position d\n, VS, P
)

Binary Search can be expressed very elegantly
using recursion
int BinSearch ( float VS, float V , int Lo,
int Hi )
int Mid
if( Lo gt Hi ) return -1
Mid ( Lo Hi ) / 2
if( VS VMid ) return Mid
if( VS lt VMid ) return BinSearch( VS, V, Lo,
Mid-1 )
else return BinSearch( VS, V, Mid1, Hi )

59
Recursive Functions

Many algorithms are beautifully and elegantly
expressed using recursion
Programming recursion requires some experience to
perfect, however it is considered a more natural
way of thinking to most humans
It is true, in general, that any iterative
algorithm can be expressed as a recursive
algorithm and vice versa.
In practice, it is not so obvious !
Students may be tested on recursion, but examples
and problems will be straightforward.

60
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

61
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

62
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

63
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

64
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

65
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

66
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

67
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

68
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

69
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

70
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

71
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

72
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

73
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

74
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

75
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

76
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

77
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

78
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

79
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

80
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

81
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

82
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

83
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

84
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

85
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

86
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

87
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

88
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

89
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

90
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

91
Towers of Hanoi

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.
!! DONE !!

92
Towers of Hanoi

Base Case 1 Move plate from A to B

93
Towers of Hanoi

Base Case 1 Move plate from A to B
Hanoi ( A, B, C, 1 ) / Move from A to B, C not
used /

94
Towers of Hanoi

Base Case 2

95
Towers of Hanoi

Base Case 2 Move top plate from A to C

96
Towers of Hanoi

Base Case 2 Move top plate from A to C
Move bottom plate from A to B

97
Towers of Hanoi

Base Case 2 Move top plate from A to C
Move bottom plate from A to B Move top plate
from C to B
Hanoi ( A, B, C, 2 ) / Move from A to B, but
use C /

An intriguing idea starts to emerge .... Hanoi (
A, B, C, 2 ) was accomplished by First applying
Hanoi ( A, C, B, 1 ) Then applying Hanoi
( A, B, C, 1 ) And, finally Hanoi ( C,
B, A, 1 )
98
Towers of Hanoi

Base Case 3 Move top plate from A to B
Move middle plate from A to C Move top plate
from B to C Move bottom plate from A to B
Move top plate from C to A Move middle plate
from C to B Move top plate from A to B

99
Towers of Hanoi

Base Case 3 Move top plate from A to B
Move middle plate from A to C Move top plate
from B to C Move bottom plate from A to B
Move top plate from C to A Move middle plate
from C to B Move top plate from A to B

100
Towers of Hanoi
This seems to be getting complicated, until we
realize that Hanoi ( A, B, C, 3 ) can be
expressed as Hanoi ( A, C, B, 2 ) Hanoi (
A2, B2, C, 1 ) Hanoi ( C, B, A, 2 )

Base Case 3 Move top plate from A to B
Move middle plate from A to C Move top plate
from B to C Move bottom plate from A to B Move
top plate from C to A Move middle plate from C
to B Move top plate from A to B

101
Towers of Hanoi
In general, applying mathematical induction, we
find that Hanoi ( A, B, C, N ) can be expressed
as void Hanoi ( int A , int B , int C ,
int N ) if( N 1 ) B0 A0 return
if( N 2 ) C0 A0 A0
B0 C0 B0 return Hanoi ( A, C,
B, N-1 ) Hanoi ( AN-1, BN-1, C, 1 )
Hanoi ( C, B, A, N-1 ) return

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.

102
Towers of Hanoi
Most people are able to grasp the sequence of
movements to solve the Towers of Hanoi
problem. The solution is recursive, built up
from handling base cases of N1, 2 and 3 plates.
Once the pattern is understood, it is then
reapplied to arbitrary N. Programming an
iterative algorithm is much harder, however. (
Try it but in your spare time )

Problem Move all plates from A to either B or
C, such that at all times smaller plates are on
top of larger plates.
!! DONE !!

103
5D Summary

Concepts Mechanisms
Searching
Sorting

104
Summary

Concepts Mechanisms
Algorithms
Searching
Sorting
Reading Chapter 6 , 7.1 7.4
Ignoring those parts that discuss technical
aspects relating specifically to
multi-dimensional arrays
Simple aspects of pointers and call-by-reference
The course may have been challenging for some
students and straightforward for others
Remember that this is what is expected of
professional experts (ie. University graduates)

105
Into the Future

A look ahead ...

106
Into the Future

Looking ahead to the 60-141 course, these topics
will be introduced or advanced.
Pointers
Multi-dimensional Arrays
String Character processing
Advanced Treatment of Functions
Abstract Data Structures
Dynamic Storage Allocation Techniques
File Based I/O
Design Programming Paradigms
Reading - Chapters 7-14 and beyond.

107
Into the Future