Loading...

PPT – CS 106 Computing Fundamentals II Chapter 77 PowerPoint presentation | free to download - id: 771db1-Mjc1M

The Adobe Flash plugin is needed to view this content

CS 106 Computing Fundamentals II Chapter

77 Algorithm

- Herbert G. Mayer, PSU CS
- Status 7/24/2013
- Initial content copied verbatim from
- CS 106 material developed by
- CS professors Cynthia Brown Robert Martin

Syllabus

- Algorithm
- Finding Smallest Element
- Find Smallest and Make it First
- Switching the Values of Variables
- Using an Array
- Sorting
- Time for Selection Sort
- Importance of Algorithm
- Software Engineering

Algorithm

- An algorithm is a finite set of instructions

which if followed will lead to a correct problem

solution in a finite amount of time - Sorting is a very important problem and has been

studied extensively - We build up a sort algorithm by starting with

finding the smallest element in an array

Finding Smallest Element

- min data(1) 'the smallest so far
- For k 2 To lastIndex
- 'test each element for min so far
- If data(k) lt min Then 'new min found
- min data(k)
- End If
- Next

Find Smallest and Make it First

- What if we want to find the smallest element and

put it first in the array? - Well do this by switching it with the first

element - We need to know the index of the smallest element

to do this - A slight modification of our code for finding the

smallest element will let us do this

Find Smallest Element and Index

- min data(1) 'the smallest so far
- minIndex 1
- For k 2 To lastNdx
- 'test each element to see if it is

the min so far - If data(k) lt min Then 'new min

found - min data(k)
- minIndex k
- End If
- Next k

Switching the Values of Variables

- Consider the following code
- varA 1
- varB 4
- varA varB
- varB varA
- What are the values of varA and varB after I do

this?

Switching the Values of Variables

- Doing it right
- varA 1
- varB 4
- temp varB
- varB varA
- varA temp
- What are the values of varA and varB after I do

this?

Now Using the Array

- find the smallest element, value and index

- min data(1) 'the smallest so far
- minIndex 1
- For k 2 To lastNdx
- 'test each element to see if it

is the min so far - If data(k) lt min Then 'new min

found - min data(k)
- minIndex k
- End If
- Next
- exchange the smallest element with the

first - temp data(1)
- data(1) data(minIndex)
- data(minIndex) temp

Sorting

- Find the smallest element in the array, and

switch it with the first one - Find the smallest element in the rest of the

array, and switch it with the second one - Etc.
- This is called selection sort

Algorithm picture (1)

- Heres an initial array
- The smallest element is in index 3. If we switch

it with the element in index 1, we get - We now know the first element is the smallest.

10 5 2 11 3

1 2 3 4 5

2 5 10 11 3

1 2 3 4 5

Algorithm picture (2)

- Looking at elements 2-5, the smallest is in index

5 - Lets switch with the element in index 2
- Now we know the first two are smallest, and are

in the right order.

2 5 10 11 3

1 2 3 4 5

2 3 10 11 5

1 2 3 4 5

Algorithm picture (3)

- Consider elements 3-5. The smallest is in

position 5. - Lets switch with the element in index 3

2 3 10 11 5

1 2 3 4 5

2 3 5 11 10

1 2 3 4 5

Algorithm picture (4)

- Consider elements 4-5. The smallest is in

position 5. - Lets switch with the element in index 4
- This finishes sorting the array (why?)

2 3 5 11 10

1 2 3 4 5

2 3 5 10 11

1 2 3 4 5

Algorithm Structure

- Starting with the whole array, then progressing

at the rest without the first element, then the

array without the second element, etc. - If we work on a whole array of n elements, thats

a loop from 1 to n, i.e. with n iterative steps - If we work on a whole array minus the first

element, that loop is from 2 to n - Next we do 3 to n, etc.

Loop Setup

- A loop from 1 to n looks like
- For k 1 To n
- ltcodegt
- Next k
- Heres a loop from 2 to n
- For k 2 To n
- ltcodegt
- Next k

In general

- We need a loop that looks like this
- For k j To n
- ltcodegt
- Next k
- for each j going from 1 to n-1. This we can do

by using another loop!

The Nested Loop

- Heres what the structure looks like
- For j 1 To n - 1
- For k j 1 To n
- ltcodegt
- Next k
- Next j

Heres the Code

- For j 1 To lastNdx 1 start with element j
- min data(j) 'the largest so far
- minIndex j
- For k j 1 To lastNdx look at

elements that follow j - If data(k) lt min Then
- min data(k)
- minIndex k
- End If
- Next k
- temp data(j) exchange the smallest

element with element j - data(j) data(minIndex)
- data(minIndex) temp
- Next j

Tricky Bits

- Note the -1 and 1 in the loop limits. Getting

those right takes some thought - Does the code work on arrays with just one

element? With two elements? With no elements?

(Nothing to sort, but we want to avoid a runtime

error.) What if the data is already sorted?

Demo Simple Sort

Other Ways of Sorting

- There are actually many ways of sorting items
- Sorting is very important so people have put a

lot of thought into it - Some well-known methods
- Bubble sort
- Quicksort
- Heapsort
- Mergesort
- Bucket sort

Which Method is Best?

- With small data sets, the best method is usually

the easiest one to program - With large data sets, speed becomes an issue
- We could measure the time with a stopwatch, but

the essential factor is the functional form of

the time if n is the length of the list of data,

is the time proportional to n? n log n? n2?

Comparison of n, n log n, n2

Time for Selection Sort

- The number of comparisons of data elements in a

sorting algorithm is usually proportional to the

time - On the first loop in Selection Sort, we do n-1

comparisons. The second loop does n-2, etc the

last loop does 1 - So the time is roughly proportional to
- (n-1) (n-2) 1 (n2 n)/2
- The largest power of n is n2 which dominates the

time for this algorithm - This means Selection Sort is actually too slow to

use on large amounts of data

Importance of Algorithms

- You now know the basics for programming

assignment statements, conditionals, procedures

and functions, loops, and arrays - This is like knowing the rules for chess or go
- What you have only started to learn are the

tactics and strategies to use these tools

effectively - Algorithms are the tactics for how to accomplish

tasks quickly and correctly

Software Engineering

- Software engineering encompasses strategies to

control the cost, design, methodology, and

complexity of large software projects - Weve been learning a few of these strategies

(e.g. naming conventions, principles of program

structure, requirements and specifications) - Good software engineering allows one person or a

large group to produce a complex program that is

correct and cost-effective