# Algorithm

Document Sample

```					           Algorithms IV

Top-Down
Design

CMSC 104                   1
Pseudocode and Then Some
     We can write an algorithm for finding the
average of two integers:
Get an integer, num1, from the user
Get an integer, num2, from the user
sum = num1 + num2
average = sum / 2
Print “The average of “ num1 “ and ” num2
“ is ” average.
 Steps 1, 2 & 5 will make use of code found
CMSC 104 in the run-time library.                    2
Investigating Steps 1 & 5
Get an integer, num1, from the user
Print “The average = “ average.
 Are these really single steps?
 Each of them is really a sequence of
steps, a subprogram. Two kinds of
subprograms:
o Functions - an answer is returned to the
main program.
o Procedures - no answer returned to the
CMSC 104     main program                               3
Functions and Procedures

 In our example, the function that gets a
value from the user and the procedure
that prints out the answer were already
written.
 Many times it is necessary for us to
write our own procedures or functions.

CMSC 104                                          4
More Problem Solving
 If we look at the problem as a whole; it
may seem impossible, because it is so
complex.
 Complex problems can be solved using
a Top-Down approach aka Stepwise
refinement
o Break the problem into parts
o Then break the parts into parts
o Soon each of the parts will be easy to do
CMSC 104                                                 5
Advantages of Top-down Design
     Breaking the problem down into parts
helps us to clarify what needs to be done.
     At each step of refinement, the new parts
become less complicated and therefore
easier to figure out.
     What if you’ve broken a problem down as
much as you can and you still don’t know?
o Missing information
o More detail is needed
CMSC 104                                                6
A Practical Example

     Scenario:
o We own a home improvement company
o We do painting, roofing and basement
waterproofing
o A section of town has recently had flooding
o We want to send out waterproofing
pamphlets to our customers in that area

CMSC 104                                                   7
Our Algorithm

 Get the customer list from a file
 Sort the list according to zipcode
 Make a new file of only the customers
with the zipcode 21222 from the sorted
customer list
 Print an envelope for each customer in
the new file

CMSC 104                                        8
Single steps ?

 None of our steps are single steps
 Employ Top-Down Design
 Start with the large idea and break into
large parts
 Each part will end up being a function or
a procedure

CMSC 104                                           9
Pseudocode for our Main Program

 Call Get Customer List
 Call Sort on customer list by zipcode
 Call Make Target List from customer list
using only zipcode 21222
 Call Print Envelopes using target list

CMSC 104                                          10
The Next Step
 Write algorithms for each of the
functions or procedures.
 These may include steps that are really
several steps, too.
 Give names to these new functions and
procedures.
 Write algorithms for them.
 Continue this process until done.

CMSC 104                                         11
Structured Programs
     Top-down design will be used for all of our
programming projects
     This is the standard way of writing programs.
     Programs produced using this method and
using only the 3 kinds of structures,
sequential, selection and repetition are called
structured programs.
     Structured programs are easier to modify
later and also easier for other programmers
to understand.
CMSC 104                                                     12
Another Example

     Problem: Write a program that draws
this picture of a house.

CMSC 104                                         13
The Algorithm

 Draw the outline of the house
 Draw the chimney
 Draw the door and doorknob
 Draw the windows

CMSC 104                               14
Similarities
 All three windows are identical.
 They are simply in different positions.
 We can write a function called
DrawWindow that will draw one window
at a position we specify and call it 3
times with the three different positions.
 Another benefit of Top-down design is
reuseability. We are reusing the code
for DrawWindow.
CMSC 104                                           15
The Pseudocode

 Call DrawHouseOutline giving a position
 Call DrawChimney giving position
 Call DrawDoor giving position
 Call DrawWindow giving position #1
 Call DrawWindow giving position #2
 Call DrawWindow giving position #3

CMSC 104                                         16
Problem Solving Techniques

     We have investigated three problem
solving techniques:
• Multiple attacks
• Working backwards
• Top-down design

CMSC 104                                        17

```
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
 views: 29 posted: 9/18/2011 language: English pages: 17