1. Efficiency of Algorithms
February 9th

2. Today Data cleanup algorithms Algorithm efficiency
Copy-over
Shuffle-left
Converging pointers
Algorithm efficiency
Efficiency of data cleanup algorithms
Reading:
Chapter 3

3. Comparing Algorithms Algorithm There are many ways to solve a problem
Design
Correctness
Efficiency
Also, clarity, elegance, ease of understanding
There are many ways to solve a problem
Conceptually
Also different ways to write pseudocode for the same conceptual idea
How to compare algorithms?

4. Efficiency of Algorithms
Efficiency: Amount of resources used by an algorithm
Space (number of variables)
Time (number of instructions)
When design algorithm must be aware of its use of resources
If there is a choice, pick the more efficient algorithm!

5. Efficiency of Algorithms
Does efficiency matter?
Computers are so fast these days…
Yes, efficiency matters a lot!
There are problems (actually a lot of them) for which all known algorithms are so inneficient that they are impractical
Remember the shortest-path-through-all-cities problem from Lab1…

6. Data Cleanup Algorithms
What are they?
A systematic strategy for removing errors from data.
Why are they important?
Errors occur in all real computing situations.
How are they related to the search algorithm?
To remove errors from a series of values, each value must be examined to determine if it is an error.
E.g., suppose we have a list d of data values, from which we want to remove all the zeroes (they mark errors), and pack the good values to the left. Legit is the number of good values remaining when we are done.
d d2 d3 d4 d5 d d7 d8
Legit

7. Data Cleanup: Copy-Over algorithm
Idea: Scan the list from left to right and copy non-zero values to a new list
Copy-Over Algorithm (Fig 3.2)
Get values for n and the list of n values A1, A2, …, An
Set left to 1
Set newposition to 1
While left <= n do
If Aleft is non-zero
Copy A left into B newposition
(Copy it into position newposition in new list
Increase left by 1
Increase newposition by 1
Else increase left by 1
Stop

8. Data Cleanup: The Shuffle-Left Algorithm
Idea:
go over the list from left to right. Every time we see a zero, shift all subsequent elements one position to the left.
Keep track of nb of legitimate (non-zero) entries
How does this work?
How many loops do we need?

9. Shuffle-Left Algorithm (Fig 3.1)
Get values for n and the list of n values A1, A2, …, An
Set legit to n
Set left to 1
Set right to 2
Repeat steps 6-14 until left > legit
6 if Aleftt ≠ 0
7 Increase left by 1
8 Increase right by 1
9 else
10 Reduce legit by 1
Repeat until right > n
Copy Aight into Aright-1
Increase right by 1
14 Set right to left + 1
15 Stop

10. Exercising the Shuffle-Left Algorithm
d d2 d3 d4 d5 d d7 d8
legit

11. Data Cleanup: The Converging-Pointers Algorithm
Idea:
One finger moving left to right, one moving right to left
Move left finger over non-zero values;
If encounter a zero value then
Copy element at right finger into this position
Shift right finger to the left

12. Converging Pointers Algorithm (Fig 3.3)
Get values for n and the list of n values A1, A2,…,An
Set legit to n
Set left to 1
Set right to n
Repeat steps 6-10 until left ≥ right
If the value of Aleft≠0 then increase left by 1
Else
Reduce legit by 1
Copy the value of Aright to Aleft
10 Reduce right by 1
if Aleft=0 then reduce legit by 1.
Stop

13. Exercising the Converging Pointers Algorithm
d d2 d3 d4 d5 d d7 d8
legit

14. Efficiency of Algorithms
How to measure time efficiency?
Running time: let it run and see how long it takes
On what machine?
On what inputs?
We want a measure of time efficiency which is independent of machine, speed etc
Look at an algorithm pseudocode and estimate its running time
Look at 2 algorithm pseudocodes and compare them

15. Time Efficiency Is this accurate? Time efficiency depends on input
(Time) efficiency of an algorithm:
the number of pseudocode instructions (steps) executed
Is this accurate?
Not all instructions take the same amount of time…
But..Good approximation of running time in most cases
Time efficiency depends on input
Example: the sequential search algorithm
In the best case, how fast can the algorithm halt?
In the worst case, how fast can the algorithm halt?

16. Efficiency of an algorithm
worst case efficiency
is the maximum number of steps that an algorithm can take for any collection of data values.
Best case efficiency
is the minimum number of steps that an algorithm can take any collection of data values.
Average case efficiency
- the efficiency averaged on all possible inputs
- must assume a distribution of the input
- we normally assume uniform distribution (all keys are equally probable)
If the input has size n, efficiency will be a function of n

17. Worst Case Efficiency for Sequential Search
Get the value of target, n, and the list of n values 1
Set index to
Set found to false
Repeat steps 5-8 until found = true or index > n n
5 if the value of listindex = target then n
Output the index
Set found to true 0
8 else Increment the index by n
9 if not found then
10 Print a message that target was not found 0
Stop
Total n+5

18. Analysis of Sequential Search
Time efficiency
Best-case : 1 comparison
target is found immediately
Worst-case: 3n + 5 comparisons
Target is not found
Average-case: 3n/2+4 comparisons
Target is found in the middle
Space efficiency
How much space is used in addition to the input?

19. Order of Magnitude Worst-case of sequential search: Simplification:
3n+5 comparisons
Are these constants accurate? Can we ignore them?
Simplification:
ignore the constants, look only at the order of magnitude
n, 0.5n, 2n, 4n, 3n+5, 2n+100, 0.1n+3 ….are all linear
we say that their order of magnitude is n
3n+5 is order of magnitude n: n+5 = (n)
2n +100 is order of magnitude n: 2n+100=(n)
0.1n+3 is order of magnitude n: 0.1n+3=(n) ….

20. Efficiency of Copy-Over
Best case:
all values are zero: no copying, no extra space
Worst-case:
No zero value: n elements copied, n extra space
Time: (n)
Extra space: n

21. Efficiency of Shuffle-Left
Space:
no extra space (except few variables)
Time
Best-case
No zero value:
no copying ==> order of n = (n)
Worst case
All zero values:
every element thus requires copying n-1 values one to the left
n x (n-1) = n2 - n = order of n2 = (n2) (why?)
Average case
Half of the values are zero
n/2 x (n-1) = (n2 - n)/2 = order of n2 = (n2)

22. Efficiency of Converging Pointers Algorithm
Space
No extra space used (except few variables)
Time
Best-case
No zero value
No copying => order of n = (n)
Worst-case
All values zero:
One copy at each step => n-1 copies
order of n = (n)
Average-case
Half of the values are zero:
n/2 copies

23. Data Cleanup Algorithms
Copy-Over
worst-case: time (n), extra space n
best case: time (n), no extra space
Shuffle-left
worst-case: time (n2), no extra space
Best-case: time (n), no extra space
Converging pointers
worst-case: time (n), no extra space