Scribd
Upload
111 views

Introduction To Computer Science I Harvard College

This document appears to be lecture notes from an introduction to computer science course. It covers topics like divide and conquer algorithms, parallel processing, asymptotic analysis of algorithms, searching algorithms like linear and binary search, sorting algorithms like bubble sort, selection sort, and merge sort. It provides pseudocode to describe algorithms and discusses running times and tradeoffs between different algorithms.

Uploaded by

paraagpandey
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
111 views

Introduction To Computer Science I Harvard College

This document appears to be lecture notes from an introduction to computer science course. It covers topics like divide and conquer algorithms, parallel processing, asymptotic analysis of algorithms, searching algorithms like linear and binary search, sorting algorithms like bubble sort, selection sort, and merge sort. It provides pseudocode to describe algorithms and discusses running times and tradeoffs between different algorithms.

Uploaded by

paraagpandey
Copyright
© Attribution Non-Commercial (BY-NC)
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 28

Computer Science 50

Introduction to Computer Science I

Harvard College

Week 3

David J. Malan
[email protected]

0
Divide and Conquer

1
Parallel Processing
1) Stand up.
2) Assign yourself the number 1.
3) Find someone else that is standing up.
(If no one is standing, remain standing until I call on you.)
4) Add your number to that person’s number;
the total is your new number.
5) One of you should then sit down.
6) If you’re still standing, go back to step 3.

2
Running Time
T (n)

20
n
18 log n
n/2
16

14

12
T(n)

10

0
0 20 40 60 80 100 120
n

3
Running Time
T (n)

Figure from C++: An Introduction to Data Structures, by Larry Nyhoff. 4


Asymptotic Notation
Informally

O
Θ
Ω
5
Asymptotic Notation
Formally
T (n) ∈ O (f (n))
We say that the running time, T (n), of an algorithm is
“in big O of f of n” iff there exist an integer n0 > 0 and
a real number c > 0 such that T (n) ≤ c · f (n) for all n ≥ n0.

T (n) ∈ Θ (f (n))
We say that the running time, T (n), of an algorithm is
“in theta of f of n” iff there exist an integer n0 and real numbers
c1, c2 > 0 such that c1 · f (n) ≤ T (n) ≤ c2 · f (n) for all n ≥ n0.

T (n) ∈ Ω (f (n))
We say that the running time, T (n), of an algorithm is
“in omega of f of n” iff there exist an integer n0 and
a real number c > 0 such that T (n) ≥ c · f (n) for all n ≥ n0.

6
O
In English

O(1) “constant”
O(log n) “logarithmic”
O(n) “linear”
O(n log n) “supralinear”
O(n2) “quadratic”
O(nc) “polynomial”
O(cn) “exponential”
O(n!) “factorial”
7
Searching

8
Linear Search
Pseudocode

On input n:
For each element i:
If i == n:
Return true.
Return false.

9
Binary Search
Iterative Pseudocode

On input array [0], ... , array [n – 1] and k:


Let first = 0.
Let last = n – 1.
While first <= last:
Let middle = (first + last ) / 2.
If k < array [middle] then let last = middle – 1.
Else if k > array [middle] then let first = middle + 1.
Else return true.
Return false.

10
Sum Looping
Get it?
int
sigma(int m)
{
int i, sum = 0;

/* avoid risk of infinite loop */


if (m < 1)
return 0;

/* return sum of 1 through m */


for (i = 1; i <= m; i++)
sum += i;
return sum;
}
see
sigma1.c

11
Sum Recursion
Get it yet?
int
sigma(int m)
{
/* base case */
if (m <= 0)
return 0;

/* recursive case */
else
return (m + sigma(m-1));
}

see
sigma2.c

12
The Stack, Revisited
Frames

13
Binary Search
Recursive Pseudocode

On input array, first, last, and k, define recurse as:


If first > last then return false.
Let middle = (first + last) / 2.
Else if k < array[middle] then
return recurse(array, first, middle – 1, k).
Else if k > array[middle] then
return recurse(array, middle + 1, last, k).
Else return true.

14
Sorting
4 2 6 8 1 3 7 5

15
Bubble Sort
Pseudocode
Repeat n times:
For each element i:
If element i and its neighbor are out of order:
Swap them.

16
Selection Sort
Pseudocode
Let i := 0.
Repeat n times:
Find smallest value, s, between i and list's end, inclusive.
Swap s with value at location i.
Let i := i + 1.

17
Sorting
Visualization

18
Merge Sort
Pseudocode

On input of n elements:
If n < 2, return.
Else
Sort left half of elements.
Sort right half of elements.
Merge sorted halves.

19
Merge Sort
Pseudocode

T (n) = 0, if n < 2

T (n) = T (n/2) + T(n/2) + O(n), if n > 1

20
Merge Sort

In the worst case,


how long does it take to sort 16 elements?

21
Merge Sort
T(16) = 2T(8) + 16
T(8) = 2T(4) +8
T(4) = 2T(2) +4
T(2) = 2T(1) +2
T(1) =0

22
Merge Sort
T (1) =0
T (2) = 2T (1) +2 =0+2 =2
T (4) = 2T (2) +4 =4+4 =8
T (8) = 2T (4) + 8 = 16 + 8 = 24
T (16) = 2T (8) + 16 = 48 + 16 = 64

23
Sorting
Visualization

24
All Sorts of Sorts
Heap Sort
Insertion Sort
Quicksort
Radix Sort
Shell Sort
...

25
Tradeoffs
Space, Time, ...

26
Computer Science 50
Introduction to Computer Science I

Harvard College

Week 3

David J. Malan
[email protected]

27

You might also like