1. Discrete Mathematics CS 2610
February 24, part 4

2. Uncountable sets Theorem: The set of real numbers is uncountable.
If a subset of a set is uncountable, then the set is uncountable.
The cardinality of a subset is at least as large as the cardinality of the entire set.
It is enough to prove that there is a subset of R that is uncountable
Theorem: The open interval of real numbers
[0,1) = {r  R | 0  r < 1} is uncountable.
Proof by contradiction using the Cantor diagonalization argument (Cantor, 1879)

3. Uncountable Sets: R
Proof (BWOC) using diagonalization: Suppose R is countable (then any subset say [0,1) is also countable). So, we can list them: r1, r2, r3, … where
r1 = 0.d11d12d13d14… the dij are digits 0-9
r2 = 0.d21d22d23d24…
r3 = 0.d31d32d33d34…
r4 = 0.d41d42d43d44…
etc.
Now let r = 0.d1d2d3d4… where di = 4 if dii  4
di = 5 if dii = 4
But r is not equal to any of the items in the list ∴ it’s missing from the list so we can’t list them after all.
r differs from ri in the ith position, for all i. So, our assumption that we could list them all is incorrect.

4. Algorithms
An Algorithm is a finite set of precise instructions for performing a computation or for solving a problem.
Properties of an algorithm:
input: input values are from a specified set
output: output values are from a specified set
definiteness: each step is precisely defined
correctness: correct output produced
finiteness: takes a finite number of steps
effectiveness: each step is finite & exact
generality: applicable to various input sizes

5. Analysis of Algorithms
Analyzing an algorithm
Time complexity
Space complexity
Running time needed by an algorithm as a function of the size of the input
Denoted as T(N)
We are interested in measuring how fast the time complexity increases as the input size grows
Asymptotic Time Complexity of an Algorithm

6. Pseudocode procedure procName(argument: type) variable := expression
informal statement
begin statements end
{comment}
if condition then statement1
[else statement2] for variable := initial value to final value statement
while condition statement
return expression
procName(arg1,..,argn)

7. Algorithm Complexity Worst Case Analysis Average Case Analysis
Largest number of operations to solve a problem of a specified size.
Analyze the worst input case for each input size.
Upper bound of the running time for any input.
Most widely used.
Average Case Analysis
Average number of operations over all inputs of a given size
Sometimes it’s too complicated

8. Example: Max Algorithm
procedure max(a1, a2, …, an: integers)
v := a1
for i := 2 to n
if ai > v then
v := ai
return v 1 n
n - 1
? 0, 1, .., n -1 1
How many times is each step executed ?
Worst-Case: the input sequence is a strictly increasing sequence

9. Searching Algorithms Searching Algorithms Problem:
Find an element x in a list a1,…an (not necessarily ordered)
Linear Search Strategy:
Examine the sequence one element after another until all the elements have been examined or the current element being examined is the element x.

10. Example: Linear Search
procedure linear search (x: integer, a1, a2, …, an: distinct integers)
i := 1
while (i  n  x  ai)
i := i + 1
if i  n then
location := i
else
location := 0
return location
Worst-Case occurs when
x is the last element in the sequence
Best Case occurs when
x is the first element in the sequence

11. Example: Linear Search
Average Case:
x is the first element:
1 loop comparison
x is the second element
2 loop comparisons, 1 iteration of the loop
x is the third element
3 loop comparisons, 2 iterations of the loop
x is n-th element
n loop comparisons, n-1 iterations of the loop

12. Binary Search
Problem: Locate an element x in a sequence of sorted elements in non-decreasing order.
Strategy: On each step, look at the middle element of the remaining list to eliminate half of it, and quickly zero in on the desired element.

13. Binary Search Suppose n=2k
procedure binary search (x:integer, a1, a2, …, an: integer)
{a1, a2, …, an are distinct integers sorted smallest to largest} i := 1 {start of search range} j := n {end of search range}
while i < j
begin m := (i +j)/2 if x > am then i := m + 1 else j := m end if x = ai then location := i else location := 0 return location
Suppose n=2k

14. Binary Search
Binary Search
The loop is executed k times
k=log2(n)

15. Linear Search vs. Binary Search
Linear Search Time Complexity:
T(n) is O(n)
Binary Search Time Complexity:
T(n) is O(log2n)

16. Sorting Algorithms
Problem: Given a sequence of numbers, sort the sequence in weakly increasing order.
Sorting Algorithms:
Input:
A sequence of n numbers a1, a2, …, an
Output:
A reordering of the input sequence (a’1, a’2, …, a’n) such that a’1  a’2  …  a’n

17. Bubble Sort
Smallest elements “float” up to the top (front) of the list, like bubbles in a container of liquid
Largest elements sink to the bottom (end).
See the animation at:

18. Example: Bubble Sort
procedure bubblesort (a1, a2, …, an: distinct integers) for i = 1 to n for j = 1 to n-i
if (aj > aj+1) then
swap aj and aj+1
Worst-Case: The sequence is sorted in decreasing order
At step i
The loop condition of the inner loop is executed n – i + 1 times.
The body of the loop is executed n – i times

19. Algorithm- Insertion Sort
For each element:
The elements on its left are already sorted
Shift the element with the element on the left until it is in the correct place.
See animation

20. Algorithm- Insertion Sort
procedure insertSort (a1, a2, …, an: distinct integers) for j=2 to n
begin
i=j - 1
while i > 0 and ai > ai+1
swap ai and ai+1
i=i-1
end
Worst-Case: The sequence is in decreasing order
At step j,
the while loop condition is executed j times
the body of the loop is executed j-1 times