Text of One-Dimensional and Multi-Dimensional Arrays, Searching & Sorting, Parameter passing to Functions...
Slide 1
One-Dimensional and Multi-Dimensional Arrays, Searching &
Sorting, Parameter passing to Functions Array Data Structures &
Algorithms
Slide 2
Concepts of Data Collections Arrays in C Syntax Usage Array
based algorithms
Slide 3
Concepts of Data Collections Sets, Lists, Vectors, Matrices and
beyond
Slide 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
Slide 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 { D x, D y, D z } along the respective x, y
and z axes, with magnitude D = sqrt(D x 2 +D y 2 +D z 2 ) We use
descriptive language terminology such as The xth component of D...
Or, D-sub-x
Slide 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 entities), and expresses the access
to object members (data values) using properties and indices based
on topologies (loosely put, shape structures)
Slide 7
Vectors, Matrices and beyond In this course we focus on an
introduction to the basic properties and algorithms associated with
vectors and matrices, and lists (later) 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
Slide 8
Arrays in C Syntax Memory structure Usage Functions
Slide 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
Slide 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
Slide 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 A[0] = 12.34 ; /* assign
12.34 to the first element */ /* NOTE: subscripts always start from
0 */ A[K] = 0.0 ; /* assign 0 to the (K+1)th element */ Note:
Although a bit clumsy in human natural language, we can change our
use of language so that A[K] always refers to the Kth element (not
K+1), always starting from 0 as the 0th element.
Slide 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.
Slide 13
Arrays in C - Syntax 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 ] ;..... } #define directives are normally
located at the beginning of the program source code, after #include
directives, and before function prototypes and the main function.
In the example, 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.
Slide 14
Arrays in C Memory structure Now consider the declaration int A
[ 9 ] ; The entire allocation unit is called A the array name There
must be 9 integer sized allocations in RAM Each element is located
contiguously (in sequence and touching) RAM AA[0] A[8]
Slide 15
Arrays in C Memory structure Arrays are often called direct
access storage containers The reference to A[K] is translated by
the compiler to First, calculate the relative address offset K *
sizeof int Second, add RAO to base address of A, or simply
&A[0] &A[K] == &A[0] + K*sizeof int RAM A[0] A[ K ]
sizeof int 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. 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 ) ; 01K01K
Slide 16
Arrays in C Usage Referencing arrays is straightforward using
the subscript notation B = A[ 5 ] ; /* assign 6 th element of A to
B */ A [ J ] < A [ K ] /* relational expression */ B = 0.5*(
A[J] A[J-1] ); /* finite difference */ printf( %d %d %d\n, A[0],
A[mid], A[N-1] ) ; scanf ( %d%lf%lf, &N, &R[K], R ) ; /*
Note */
Slide 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 ;
Slide 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( K=0; K < N; K++ ) { scanf( %f,
&A[K] ) ; /* NOTE: & must be used */ Sum += A[K] ; }
Slide 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 );
Slide 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 < N ; K++ ) scanf( %d%f, &SID[K], &Mark[K] )
;
Slide 21
Arrays in C Functions 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: U[0], U[1], U[2] V[0], V[1], V[2] Mathematics: The dot
product is defined as DotProd( U, V ) ::= U[0]*V[0] + U[1]*V[1] +
U[2]*V[2] Since the dot product operation is required often, it
would make a useful function. U V U. V
Slide 22
Arrays in C Functions Solution function: double DotProd3 (
double U[3], double V[3] ) { return U[0] * V[0] + U[1] * V[1] +
U[2] * V[2] ; } 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
Slide 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 < N ; K++ )
DPN += U[K] * V[K] ; 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.
Slide 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 < N ; K++ ) DPN +=
U[K] * V[K] ; return DPN ; } Note the array arguments are now
expressed as pointer references. This maintains the same
flexibility as previously.
Slide 25
Arrays in C Functions 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
< 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.
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 &A[K]), then P++ evaluates to the next (or successor)
value in sequence, which is usually the next element of an array
(ie. &A[K=1]).
Slide 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 U[3], double V[3] ); 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
U[3]), 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)
Slide 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
Slide 28
Array Based Algorithms Searching Sorting
Slide 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
Slide 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
Slide 31
Search Algorithms - Random 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( K=rand() % N ; srchID != SID[ K ] ;
K=rand() % N ) ; printf( SID = %d, Mark = %f\n, SID[K], Mark[K] );
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).
Slide 32
Search Algorithms - Linear 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( K=0; KN ? ) 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. N
Slide 45
Sorting Algorithms.... Putting things in order........ order
things Putting in....
Slide 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
Slide 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.......... 82 45 31 72 56 62 87 90
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 K=0) 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.
Slide 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 */ 31 45 56 62 72
82 87 90 0 N-1 (N-1-K)
Slide 52
Sorting Algorithms - Selection void SelectionSort ( double
List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J <
N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P]
< List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ;
List[N-1-J] = Temp ; } } Swapping of array elements must be done
with some care and thought. Three statements are required, and a
temporary storage variable must be used. Temp List[P] List[N-1-J]
62 56 1 62 2 3 56 62
Slide 53
Sorting Algorithms - Selection void SelectionSort ( double
List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J <
N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P]
< List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ;
List[N-1-J] = Temp ; } } /* Define a dswap function */ void dswap (
double * A, double * B ) { double T ; T = *A ; *A = *B ; *B = T ;
return ; } dswap ( &List[P], &List[N-1-J] ) ;
Slide 54
Sorting Algorithms - Selection void SelectionSort ( double
List[ ], int N ) { int J, K, P ; double Temp ; for( J = 0 ; J <
N-1 ; J++ ) { P = 0 ; for( K = 0 ; K < N - J ; K++ ) if( List[P]
< List[K] ) P = K ; Temp = List[P] ; List[P] = List[N-1-J] ;
List[N-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
Slide 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 )
Slide 56
Sorting Algorithms There are many other sorting algorithms
BubbleSort InsertionSort QuickSort MergeSort Some of these are
iterative, while others are recursive. A number of sorting
algorithms exhibit time complexities of O( N 2 ), but some achieve
better efficiencies (eg. O( N log N ) ) under certain
circumstances. Additional algorithms will be discussed later in
60-141 and other computer science courses
Slide 57
Bubble Sort void BubbleSort ( double List[ ], int N ) { int J,
K ; for( J = 0 ; J < N-1 ; J++ ) for( K=0; K
Recursive Binary Search Binary Search can be expressed very
elegantly using recursion int BinSearch ( float VS, float V[ ], int
Lo, int Hi ) { int Mid ; if( Lo > Hi ) return -1 ; Mid = ( Lo +
Hi ) / 2 ; if( VS == V[Mid] ) return Mid ; if( VS < V[Mid] )
return BinSearch( VS, V, Lo, Mid-1 ); else return BinSearch( VS, V,
Mid+1, Hi ); } 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 ) ;
Slide 60
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 will be
tested on recursion.
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 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. ABC
Slide 92
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 !! ABC
Slide 93
Towers of Hanoi Base Case 1 :: Move plate from A to B ABC
Slide 94
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 */ ABC
Slide 95
Towers of Hanoi Base Case 2 :: ABC
Slide 96
Towers of Hanoi Base Case 2 :: Move top plate from A to C
ABC
Slide 97
Towers of Hanoi Base Case 2 :: Move top plate from A to C Move
bottom plate from A to B ABC
Slide 98
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 */ ABC 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 )
Slide 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 ABC
Slide 100
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 ABC
Slide 101
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 ABC 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 ( &A[2], &B[2],
C, 1 ) ; Hanoi ( C, B, A, 2 ) ;
Slide 102
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. ABC 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 ) { B[0] = A[0] ;
return ; } if( N == 2 ) { C[0] = A[0] ; A[0] = B[0] ; C[0] = B[0] ;
return ; } Hanoi ( A, C, B, N-1 ) ; Hanoi ( &A[N-1],
&B[N-1], C, 1 ) ; Hanoi ( C, B, A, N-1 ) ; return ; }
Slide 103
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 !! ABC 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 N=1, 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 :)
Slide 104
Multi-Dimensional Arrays Consider the case of student marks
(0.0 to 10.0) for several assignments, all stored in a 2-
dimensional array of float values #define MAX_STUDS 120 #define
NUM_ASSIGNS 10 float Mark [ MAX_STUDS ] [ NUM_ASSIGNS ] ; Assume
data is in a file called InData.dat. StudentNumber
AssignNumber
Slide 105
Multi-Dimensional Arrays We assume that the input file
InData.dat has been prepared as follows: The file may be empty, in
which case the end-of-file indicator can be checked using EOF A
non-empty file contains (at the least) One line containing two
integer values greater or equal to zero These correspond to the
number of students and number of assignments, respectively The rest
of the file contains A line containing an integer, the Student
Number, followed by A line containing the marks as floating point
values. The number of marks corresponds to the number of
assignments specified. The file terminates when the end-of-file
indicator arises and is checked using EOF. Marks must be inserted
according to the Student Number value (in the range from 0 to
MAX_STUDS-1). StudentNumber AssignNumber
Slide 106
Multi-Dimensional Arrays /* Input from InData.dat using input
redirection cmdprompt:>a.out < InData.dat */ #define
MAX_STUDS 120 #define NUM_ASSIGNS 10 float Mark [ MAX_STUDS ] [
NUM_ASSIGNS ] ; int NumberStudents, NumberAssignments, StudNum ;
int S, A ; /* Utility integers */ /* Test input file for data */
if( (A=scanf( %d%d, &NumberStudents, &NumberAssignments ))
== EOF ) return 0 ; /* Data exists, so input data until EOF is
encountered */ for( S=0 ; S < NumberStudents ; S++ ) { if (
(A=scanf( %d, &StudNum )) == EOF ) break; /* A record exists so
input assignment marks */ for( A=0 ; A < NumberAssignments ; A++
) scanf( %f, &Mark[ StudNum ][A] ) ; }
Slide 107
Multi-Dimensional Arrays N-D Arrays as function arguments
Unlike 1-D arrays, all array maximum dimensions must be declared
explicitly (except for the leftmost dimension) Example InputMarks(
NS, NA, Mark ) Prototype void InputMarks( int, int, float [][
NUM_ASSIGNS ] ) ; Function Definition void InputMarks( int NS, int
NA, float M[][ NUM_ASSIGNS ] ) { /* variable defns, logic */ return
; }
Slide 108
Multi-Dimensional Arrays Memory allocation of 2D arrays is done
(typically) using Row Major Ordering. The compiler must know, in
advance, what size of allocation to provide for each row The actual
number of rows is not important 123 456 789 101112 1 2 3 4 5 6 7 8
9 10 11 12
Slide 109
Multi-Dimensional Arrays Memory allocation of 2D arrays is done
(typically) using Row Major Ordering. The compiler must know, in
advance, what size of allocation to provide for each row The actual
number of rows is not important The compiler replaces subscript
references by Base address pointer plus relative offset The Base
address is just the address of the first element in the 2D array,
or &A[0][0] The relative offset is given by Rowsub * ( #Columns
* sizeof elementtype) + Colsub * sizeof elementtype To compute this
expression requires the #Columns void InputMarks( int, int, float
[] [NUM_ASSIGNS] ) ; Rowsub * ( #Columns * sizeof elementtype) +
Colsub * sizeof elementtype Higher dimensional arrays must specify
all lower dimensions maximum values, leaving only the highest
dimension unspecified. Example prototype statement for a 3D array:
int Func( int Array [ ] [ MAX_ROW ] [ MAX_COL ], int Page, int Row,
int Col ) ; The allocation is understood in terms of Page Major
Ordering which requires that the compiler know MAX_ROW and MAX_COL
in advance.
Slide 110
Multi-Dimensional Arrays Working with 2-D arrays necessitates
thought and care about the operations to be performed on them and
how they are defined and referenced Matrix Transpose - Transpose(
A, AT, NR, NC ) Interchange rows and columns Prototype: void
Transpose( float [ ] [MC], float [ ] [MR], int, int ) ; The result
array must be defined to be of suitable size If we define: float A
[MR] [MC]; then we must define: float AT [MC] [MR]; Key statement
for( r=0; r A[ r2 ][ 0 ] ) for( c=0 ; c