One-Dimensional Arrays, Searching - PowerPoint PPT Presentation

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:262
Avg rating:3.0/5.0
Slides: 109
Provided by: DrRo123
Category:

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
  • Dont forget to complete and submit the last
    assignment
  • Due the day after the Final Examination
  • Study hard for the Final Examination
  • Review all slides, review the assigned textbook
    readings
  • Review all labs, assignments and examples (slides
    and textbook)
  • Focus on material covered from second midterm to
    end of lectures

108
Into the Future
  • I wish you all a safe and satisfying summer,
    whether vacationing or working.
  • Good luck to those taking additional courses
  • Work hard and make your own good luck!
  • - Dr. Bob Kent

The end of the beginning
Write a Comment
User Comments (0)
About PowerShow.com