Section Summary

 Properties of Algorithms
 Algorithms for Searching and Sorting
 Greedy Algorithms
 Halting Problem

2
Problems and Algorithms
 In many domains there are key general problems that
ask for output with specific properties when given
valid input.
 The first step is to precisely state the problem, using
the appropriate structures to specify the input and the
desired output.
 We then solve the general problem by specifying the
steps of a procedure that takes a valid input and
produces the desired output. This procedure is called
an algorithm.

3
Algorithms Abu Ja’far Mohammed Ibin Musa Al-Khowarizmi
(780-850)
Definition: An algorithm is a finite set of precise
instructions for performing a computation or for solving a
problem.
Example: Describe an algorithm for finding the maximum
value in a finite sequence of integers.

4
Algorithms Abu Ja’far Mohammed Ibin Musa Al-Khowarizmi
(780-850)
Definition: An algorithm is a finite set of precise
instructions for performing a computation or for solving a
problem.
Example: Describe an algorithm for finding the maximum
value in a finite sequence of integers.
Solution: Perform the following steps:
1. Set the temporary maximum equal to the first integer in the
sequence.
2. Compare the next integer in the sequence to the temporary
maximum.
 If it is larger than the temporary maximum, set the temporary
maximum equal to this integer.
3. Repeat the previous step if there are more integers. If not, stop.
4. When the algorithm terminates, the temporary maximum is the
largest integer in the sequence.

5
Specifying Algorithms
 Algorithms can be specified in different ways. Their steps can be
described in English or in pseudocode.
 Pseudocode is an intermediate step between an English language
description of the steps and a coding of these steps using a
programming language.
 The form of pseudocode we use is specified in Appendix 3. It uses
some of the structures found in popular languages such as C++ and
Java.
 Programmers can use the description of an algorithm in pseudocode to
construct a program in a particular language.
 Pseudocode helps us analyze the time required to solve a problem
using an algorithm, independent of the actual programming language
used to implement algorithm.

6
Properties of Algorithms
 Input: An algorithm has input values from a specified set.
 Output: From the input values, the algorithm produces the
output values from a specified set. The output values are
the solution.
 Correctness: An algorithm should produce the correct
output values for each set of input values.
 Finiteness: An algorithm should produce the output after a
finite number of steps for any input.
 Effectiveness: It must be possible to perform each step of
the algorithm correctly and in a finite amount of time.
 Generality: The algorithm should work for all problems of
the desired form.

7
Finding the Maximum Element in a
Finite Sequence
 The algorithm in pseudocode:

procedure max(a1, a2, …., an: integers)

max := a1
for i := 2 to n
if max < ai then max := ai
return max{max is the largest
element}

 Does this algorithm have all the properties listed on

the previous slide?

8
Some Example Algorithm Problems
 Three classes of problems will be studied in this
section.
1. Searching Problems: finding the position of a
particular element in a list.
2. Sorting problems: putting the elements of a list into
increasing order.
3. Optimization Problems: determining the optimal value
(maximum or minimum) of a particular quantity over
all possible inputs.

9
Searching Problems
Definition: The general searching problem is to locate
an element x in the list of distinct elements a1,a2,...,an,
or determine that it is not in the list.
 The solution to a searching problem is the location of
the term in the list that equals x (that is, i is the solution
if x = ai) or 0 if x is not in the list.
 For example, a library might want to check to see if a
patron is on a list of those with overdue books before
allowing him/her to checkout another book.
 We will study two different searching algorithms; linear
search and binary search.

10
Linear Search Algorithm
 The linear search algorithm locates an item in a list by examining elements in
the sequence one at a time, starting at the beginning.
 First compare x with a1. If they are equal, return the position 1.
 If not, try a2. If x = a2, return the position 2.
 Keep going, and if no match is found when the entire list is scanned,
return 0.
procedure linear search(x:integer,
a1, a2, …,an: distinct integers)
i := 1
while (i ≤ n and x ≠ ai)
i := i + 1
if i ≤ n then location := i
else location := 0
return location{location is the subscript of the term that
equals x, or is 0 if x is not found}
11
Binary Search
 Assume the input is a list of items in increasing order.
 The algorithm begins by comparing the element to be found
with the middle element.
 If the middle element is lower, the search proceeds with the upper
half of the list.
 If it is not lower, the search proceeds with the lower half of the list
(through the middle position).
 Repeat this process until we have a list of size 1.
 If the element we are looking for is equal to the element in the list,
the position is returned.
 Otherwise, 0 is returned to indicate that the element was not
found.
 In Section 3.3, we show that the binary search algorithm is much
more efficient than linear search.

12
Binary Search
 Description of the binary search algorithm in pseudocode.

procedure binary search(x: integer, a1,a2,…, an: increasing integers)

i := 1 {i is the left endpoint of interval}
j := n {j is right endpoint of interval}
while i < j
m := ⌊(i + j)/2⌋
if x > am then i := m + 1
else j := m
if x = ai then location := i
else location := 0
return location{location is the subscript i of the term ai equal to x,
or 0 if x is not found}
13
 procedure binary search(x: integer, a1,a2,…, an: increasing integers)
i := 1 {i is the left endpoint of interval}
j := n {j is right endpoint of interval}
while i < j
m := ⌊(i + j)/2⌋
if x > am then i := m + 1
else j := m
if x = ai then location := i
else location := 0
return location{location is the subscript i of the term ai equal to x,
or 0 if x is not found}
Example: The steps taken by a binary search for 19 in the list:
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
1. The list has 16 elements, so the midpoint is 8. The value in the 8 th position is 10. Since
19 > 10, further search is restricted to positions 9 through 16.
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
2. The midpoint of the list (positions 9 through 16) is now the 12 th position with a value
of 16. Since 19 > 16, further search is restricted to the 13 th position and above.
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
3. The midpoint of the current list is now the 14 th position with a value of 19. Since
19 ≯ 19, further search is restricted to the portion from the 13 th through the 14 th
positions .
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
4. The midpoint of the current list is now the 13 th position with a value of 18.
Since 19> 18, search is restricted to the portion from the 18 th position through the
18th.
1 2 3 5 6 7 8 10 12 13 15 16 18 19 20 22
5. Now the list has a single element and the loop ends. Since 19=19, the location 16 is
returned.
14
Sorting
 To sort the elements of a list is to put them in increasing order
(numerical order, alphabetic, and so on).
 Sorting is an important problem because:
 A nontrivial percentage of all computing resources are devoted to
sorting different kinds of lists, especially applications involving
large databases of information that need to be presented in a
particular order (e.g., by customer, part number etc.).
 An amazing number of fundamentally different algorithms have
been invented for sorting. Their relative advantages and
disadvantages have been studied extensively.
 Sorting algorithms are useful to illustrate the basic notions of
computer science.
 A variety of sorting algorithms are studied in this book; binary,
insertion, bubble, selection, merge, quick, and tournament.
 In Section 3.3, we’ll study the amount of time required to sort a
list using the sorting algorithms covered in this section.
15
Bubble Sort
 Bubble sort makes multiple passes through a list. Every
pair of elements that are found to be out of order are
interchanged.

procedure bubblesort(a1,…,an: real numbers

with n ≥ 2)
for i := 1 to n− 1
for j := 1 to n − i
if aj >aj+1 then interchange aj and aj+1
{a1,…, an is now in increasing order}

16
 procedure bubblesort(a1,…,an: real numbers
with n ≥ 2)
for i := 1 to n− 1
for j := 1 to n − i
if aj >aj+1 then interchange aj and aj+1
{a1,…, an is now in increasing order}
Example: Show the steps of bubble sort with 3 2 4 1 5

 At the first pass the largest element has been put into the correct position
 At the end of the second pass, the 2nd largest element has been put into the correct
position.
 In each subsequent pass, an additional element is put in the correct position. 17
Insertion Sort
 Insertion sort begins with the 2nd element. It compares the 2nd element
with the 1st and puts it before the first if it is not larger.
procedure insertion sort
•Next the 3rd element is put into (a1,…,an:
the correct position among the real numbers with n ≥ 2)
first 3 elements. for j := 2 to n
•In each subsequent pass, the n+1st i := 1
element is put into its correct while aj > ai
position among the first n+1 i := i + 1
elements.
•Linear search is used to find the
m := aj
correct position. for k := 0 to j − i − 1
aj-k := aj-k-1
ai := m
{Now a1,…,an is in increasing order}
18
 Example: Show all the steps of insertion sort with the
input: 3 2 4 1 5
i. 2 3 4 1 5 (first two positions are interchanged)
ii. 2 3 4 1 5 (third element remains in its position)
iii. 1 2 3 4 5 (fourth is placed at beginning)
iv. 1 2 3 4 5 (fifth element remains in its position)
procedure insertion sort
(a1,…,an:
real numbers with n ≥ 2)
for j := 2 to n
i := 1
while aj > ai
i := i + 1
m := aj
for k := 0 to j − i − 1
aj-k := aj-k-1
ai := m
{Now a1,…,an is in increasing order} 19
Greedy Algorithms
 Optimization problems minimize or maximize some parameter over all possible
inputs.
 Among the many optimization problems we will study are:
 Finding a route between two cities with the smallest total mileage.
 Determining how to encode messages using the fewest possible bits.
 Finding the fiber links between network nodes using the least amount of fiber.
 Optimization problems can often be solved using a greedy algorithm, which
makes the “best” choice at each step. Making the “best choice” at each step does
not necessarily produce an optimal solution to the overall problem, but in
many instances, it does.
 After specifying what the “best choice” at each step is, we try to prove that this
approach always produces an optimal solution, or find a counterexample to
show that it does not.
 The greedy approach to solving problems is an example of an algorithmic
paradigm, which is a general approach for designing an algorithm. We return to
algorithmic paradigms in Section 3.3.

20
Greedy Algorithms: Making Change
Example: Design a greedy algorithm for making change
(in U.S. money) of n cents with the following coins:
quarters (25 cents), dimes (10 cents), nickels (5 cents), and
pennies (1 cent) , using the least total number of coins.
Idea: At each step choose the coin with the largest possible
value that does not exceed the amount of change left.
1. If n = 67 cents, first choose a quarter leaving
67−25 = 42 cents. Then choose another quarter leaving
42 −25 = 17 cents
2. Then choose 1 dime, leaving 17 − 10 = 7 cents.
3. Choose 1 nickel, leaving 7 – 5 – 2 cents.
4. Choose a penny, leaving one cent. Choose another penny
leaving 0 cents.

21
Greedy Change-Making Algorithm
Solution: Greedy change-making algorithm for n cents. The
algorithm works with any coin denominations c1, c2, …,cr .
procedure change(c1, c2, …, cr: values of coins, where c1> c2> … > cr ;
n: a positive integer)
for i := 1 to r
di := 0 [di counts the coins of denomination ci]
while n ≥ ci
di := di + 1 [add a coin of denomination ci]
n = n - ci
[di counts the coins ci]

 For the example of U.S. currency, we may have quarters, dimes,

nickels and pennies, with c1 = 25, c2 = 10, c3 = 5, and c4 = 1.

22
 Halting Problem (intuition)
 Is there a program that never stops but you can't prove it?
The answer turns out to be "yes", and we can even prove it.
 Suppose that we have an algorithm that could answer the
halting problem. However complicated it might be, we
just wrap it up in a decision box. We do not worry about
what is inside; we are just positing that there could be
something in there.

This and next slide based on Quara by Joshua Engel

23
 Now, let us make up a
program that uses it:

OK, now... what happens if we feed this program to itself? If it doesn't halt, then it
halts. If it does halt, then it doesn't halt. So, does it halt or not?

The answer is that there is no answer. It is the computer programming equivalent of

saying "I always lie": if it's true, then it's not true, and if it's not true, then it's true.

In other words, the answer to the question is undecideable, neither true nor false. We
conclude that the magic diamond "does it halt" box doesn't exist, which is interesting.
But even more interesting is the fact that we've taken a simple yes/no question and
found that we cannot know the answer in all cases.
24
 Barber paradox
 It was used by Bertrand Russell as an illustration of a paradox.
 The barber is the "one who shaves all those, and those
only, who do not shave themselves."
 The question is, does the barber shave himself?
 Answering this question results in a contradiction. The
barber cannot shave himself as he only shaves those who do
not shave themselves. As such, if he shaves himself he ceases
to be a barber.
 In first order logic:

25
Halting Problem (more formal)
Can we develop a procedure that takes as input a
computer program along with its input and
determines whether the program will eventually halt
with that input.
 Solution: Proof by contradiction.
 Assume that there is such a procedure and call it
H(P,I). The procedure H(P,I) takes as input a program
P and the input I to P.
 H outputs “halt” if it is the case that P will stop when
run with input I.
 Otherwise, H outputs “loops forever.”

26
Halting Problem
 Since a program is a string of characters, we can call
H(P,P). Construct a procedure K(P), which works as
follows.
 If H(P,P) outputs “loops forever”, then K(P) halts.
 If H(P,P) outputs “halt”, then K(P) goes into an infinite
loop printing “ha” on each iteration.

27
Halting Problem
 Now we call K with K as input, i.e. K(K).
 If the output of H(K,K) is “halts”, then K(K) loops
forever. A Contradiction.
 If the output of H(K,K) is “loops forever”, then K(K)
halts. A Contradiction.
 Therefore, there cannot be a procedure that can decide
whether or not an arbitrary program halts. The halting
problem is unsolvable.

28