Question 1:
Given the Selection Sort and Binary search algorithms you have already seen in introduction to CS:
public static void selectionSort(int[] arr){
// Assumes a!=null, a is sorted
int i = 0;
public static int binarySearch(int[] arr, int key){
while (i<arr. length-1){
int ans = -1; // default (not found) value
int minInd = minIndex(arr,i) ;
boolean found = false;
swap(arr,i,minInd) ;
int low = 0;
i=i+1;
int high = arr. length-1;
}
while (low <= high & !found){
} // selectionSort
int middle = (low+high)/2;
if(arr[middle] == key){
// Assumes arr!=null
ans = middle;
public static int minIndex(int[] arr, int from) {
found = true;
int ans = from;
}
for(int i =from+1; i<arr. length; i=i+1)
else if (key < arr[middle])
if (arr[ans] > arr[i])
high = middle-1;
ans = i;
else low = middle+1;
return ans;
}
} // minIndex
return ans;
} // binarySearch
//swap element arr[i] with arr[j]
public static void swap(int[] arr, int i, int j){
int tmp = arr[i] ;
arr[i] = arr[j] ;
arr[j] = tmp;
} // swap
Analyze the run-time of each of the functions above (denote arr.length =n):
1. Directly (without bounds).
minIndex : n-from+2
swap : 3
selectionSort:
𝑛2
2
+
11
𝑛
2
+2
binarySearch: 5 + 2 log 2 𝑛
2. Using asymptotic notations (prove your claims).
minIndex : O(n) , pick any number bigger than 1 as constant c and index bigger than
2−𝑓𝑟𝑜𝑚
𝑐−1
swap : O(1) pick constant 4 or higher
selectionSort: O(n^2), pick constant c bigger than 1/2 and any index bigger than
11
2
121
−4+8𝑐
4
− +√
1−2𝑐
5



binarySearch: O(log(n)) , pick any constant c>2 and index bigger than 2𝑐−2
Assume that getting the length of an array, accessing a location and mathematical operations
(including a chain of operations, meaning for example (1+1)/2 ) are atomic actions.
Assume worst case scenario, for example in the binary search we never find the value we
search for, until the last search.
Do not count loop condition checking (for, while ..) as operations.
Question 2:
Look at the following function:
public static int sortAndBinarySearch(int[] a, int key){
int[] b = selectionSort(a);
int found = binarySearch(b,key);
return found;
} // binarySearch
Categorize the following functions into 3 groups by their relationship with
sortAndBinarySearch (𝑡ℎ𝑒 𝑔𝑟𝑜𝑢𝑝𝑠 𝑤𝑒 𝑤𝑎𝑛𝑡 𝑎𝑟𝑒 Ω, 𝑂, Θ )
SortAndBinarySearch: O(n^2)
1. 𝑛 : in Ω
2. 𝑛3 + 2𝑛2 − 100001 : in O
3. log 2 (𝑛) : in Ω
2
4. log 2 (3𝑛 + 9) : in Θ
𝑛4 −2
5. 𝑛2 +300 : in Θ
6. (𝑛 − 1)! : in O
7. 𝑛𝑛 : in 𝑂
For example the running time of mergeSort is 𝑛𝑙𝑜𝑔𝑛 and if we want to compare it to the
functions 𝑛𝑙𝑜𝑔𝑛 , 𝑛 and 𝑛2 then 𝑛 ∈ 𝑂(𝑛𝑙𝑜𝑔𝑛), 𝑛2 ∈ Ω(𝑛𝑙𝑜𝑔𝑛) and 𝑛𝑙𝑜𝑔𝑛 ∈ Θ(𝑛𝑙𝑜𝑔𝑛)


Assume worst case scenario, for example in the binary search we never find the value we
search for, until the last search.
Do not count return statements or condition checking (for, while ..) as operations.
Question 3:
Prove / disprove:
2
1. There exist f such that 𝑓(𝑛) = (log 𝑛) and (𝑓(𝑛)) = 𝑂(𝑓(𝑛)).
False.
2
Let's falsely assume that there exist 𝑛0 , 𝑐 ≥ 0 such that ∀𝑛 > 𝑛0, (𝑓(𝑛)) ≤ 𝑐 ⋅ 𝑓(𝑛).
Then ∀𝑛 > 𝑛0, 𝑓(𝑛) ≤ 𝑐, in contradiction to the fact that 𝑓(𝑛) = Ω(log 𝑛).
2. If f and g are monotonically increasing functions, such that 𝑓(𝑔(𝑛)) = 𝑂(𝑛) and 𝑓(𝑛) =
(𝑛), then 𝑔(𝑛) = 𝑂(𝑛).
True.
𝑓(𝑔(𝑛)) = 𝑂(𝑛), so there exist constants 𝑛1 , 𝑐1 > 0 such that ∀𝑛 ≥ 𝑛1, 𝑓(𝑔(𝑛)) ≤ 𝑐1 𝑛.
𝑓(𝑛) = (𝑛), so there exist constants 𝑛2 , 𝑐2 > 0 such that ∀𝑛 ≥ 𝑛2 , 𝑓(𝑛) ≥ 𝑐2 𝑛
Case 1: if 𝑔(𝑛) is bounded by 𝑛2 than it is trivial, since 𝑔(𝑛) = 𝑂(1).
Case 2: there exist a constant 𝑛3 such that ∀𝑛 ≥ 𝑛3 , 𝑔(𝑛) ≥ 𝑛2 (since g is monotonically
increasing). Let 𝑛0 = max{𝑛1 , 𝑛3 }, then ∀𝑛 ≥ 𝑛0,
𝑐
𝑐2 𝑔(𝑛) ≤ 𝑓(𝑔(𝑛)) ≤ 𝑐1 𝑛 => 𝑔(𝑛) ≤ 𝑐1 ⋅ 𝑛, thus 𝑔(𝑛) = 𝑂(𝑛).
2
3. max(𝑓(𝑛), 𝑔(𝑛)) = Θ(𝑓(𝑛) + 𝑔(𝑛))
True.
We need to show 𝑐1 (𝑓(𝑛) + 𝑔(𝑛)) ≤ max(𝑓(𝑛), 𝑔(𝑛)) ≤ 𝑐2 (𝑓(𝑛) + 𝑔(𝑛)).
Selectin 𝑐2 = 1 shows the second inequality, since the maximum must be smaller than the
sum.
1
Selectin 𝑐1 = 2 shows the first inequality, since the maximum is always greater than the
average.
Question 4:
Prove or give a counter example for the following asymptotic notation properties (in all sections
you may assume that 𝑓(𝑛) ≥ 1 and 𝑔(𝑛) ≥ 1 for all n):
2
a. 𝑓(𝑛) = 𝑂 ((𝑓(𝑛)) )
2
We need to show 𝑓(𝑛) ≤ 𝑐 ⋅ (𝑓(𝑛)) .
Divide both sides by 𝑓(𝑛) (it is ok since 𝑓(𝑛) ≥ 1 for all n). We get 1 ≤ 𝑐 ⋅ 𝑓(𝑛)
2
Choose 𝑐 = 1, 𝑛0 = 1. Then 𝑓(𝑛) ≤ 𝑐 ⋅ (𝑓(𝑛)) ∀ 𝑛 ≥ 𝑛0 .
b. If 𝑓(𝑛) = 𝑂(𝑛) then 2 𝑓(𝑛) = 𝑂(2𝑛 )
The claim is false. Counter example:
Let 𝑓(𝑛) = 2𝑛, so the condition is met: 𝑓(𝑛) = 𝑂(𝑛). However, in order to prove that
2 𝑓(𝑛) = 𝑂(2𝑛 ) we need to show that for some constant c and for all 𝑛 ≥ 𝑛0 : 22𝑛 ≤ 𝑐 ⋅ 2𝑛 .
By dividing by 2𝑛 , we get: 2𝑛 ≤ 𝑐, which cannot be true for all 𝑛 ≥ 𝑛0 .
Question 5:
Prove the following claims:
a. (𝑛 + 1)5 = 𝑂(𝑛5 )
We need to show that (𝑛 + 1)5 ≤ 𝑐 ⋅ 𝑛5 𝑓𝑜𝑟 𝑛 ≥ 𝑛0 .
1 5
divide both sides by 𝑛5 ⇒ (1 + 𝑛) ≤ 𝑐. Choose 𝑛0 = 1, 𝑐 = 32.
b. 3𝑛 ⋅ log 𝑛 + 2𝑛 = 𝛺(𝑛 ⋅ log 𝑛)
We need to show that 𝑐 ⋅ 𝑛 ⋅ log 𝑛 ≤ 3𝑛 ⋅ log 𝑛 + 2𝑛 𝑓𝑜𝑟 𝑛 ≥ 𝑛0 .
2
divide both sides by 𝑛 ⋅ log 𝑛 ⇒ 𝑐 ≤ 3 + log 𝑛. Choose 𝑛0 = 2, 𝑐 = 3.
c. 𝑛 ⋅ (2𝑛 + 3𝑛+1 )2 = 𝑂(𝑛 ⋅ 9𝑛 )
𝑛 ⋅ (2𝑛 + 3𝑛+1 )2 = 𝑛 ⋅ ((2𝑛 )2 + 2 ⋅ 2𝑛 ⋅ 3𝑛+1 + (3𝑛+1 )2 )
= 𝑛 ⋅ (22𝑛 + 2 ⋅ 2𝑛 ⋅ 3 ⋅ 3𝑛 + 32𝑛+2 ) = 𝑛 ⋅ (4𝑛 + 6 ⋅ 6𝑛 + 9 ⋅ 9𝑛 )
= 𝑂(𝑛 ⋅ 9𝑛 )
d. log 3 2𝑛 = 𝑂(𝑛)
log 3 2𝑛 ≤ log 2 2𝑛 = 𝑛 ⋅ log 2 2 = 𝑛 ≤ 𝑐 ⋅ 𝑛. This holds for c=1 and any n.
Question 6:
Solve the following recurrence. Assume that 𝑇(1) = 𝑇(2) = (1).
𝑛
2
a. 𝑇(𝑛) = 2𝑇 ( ) + 𝑛3
Use the Master theorem
𝑛log𝑏 𝑎 = 𝑛log2 2 = 𝑛
𝑓(𝑛) = 𝑛3 = Ω(𝑛1+𝜖 ), 𝑙𝑒𝑡𝑠 𝑐ℎ𝑜𝑜𝑠𝑒 𝜖 = 1
𝑛
𝑛 3
2
𝑎 ⋅ 𝑓 ( ) = 2 ⋅ ( ) < 𝑐 ⋅ 𝑛3 ⇒ 𝑛3 < 𝑐 ⋅ 𝑛3
𝑏
2
8
2
True for every ≤ 𝑐 < 1
8
Third case of the Master theorem: 𝑇(𝑛) = Θ(𝑛3 )
𝑛
b. 𝑇(𝑛) = 2𝑇 (4 ) + 1
Iteration methos:
𝑛
𝑛
𝑛
𝑇(𝑛) = 1 + 2𝑇 (4 ) = 1 + 2 (1 + 2𝑇 (16)) = 1 + 2 (1 + 2 (1 + 2 (64))) = 1 + 2 +
22 + ⋯ + 2log4 𝑛 = 1 ⋅
2log4 𝑛 −1
2−1
= 2log2 √𝑛 − 1 = √𝑛 − 1 = Θ(√𝑛)
1
Master theorem: Since 1 is 𝑂(𝑛log4 2 ) then 𝑇 = Θ(𝑛log4 2 ) = Θ (𝑛2 )
c. 𝑇(𝑛) = 𝑇(𝑛 − 1) + 𝑛
Use Iteration method
𝑇(𝑛) = 𝑇(𝑛 − 1) + 𝑛 =
= [𝑇(𝑛 − 2) + (𝑛 − 1)] + 𝑛 = 𝑇(𝑛 − 2) + 𝑛 + (𝑛 − 1) =
= [𝑇(𝑛 − 3) + (𝑛 − 2)] + 𝑛 + (𝑛 − 1) = 𝑇(𝑛 − 3) + 𝑛 + (𝑛 − 1) + (𝑛 − 2) =
…
= 𝑇(𝑛 − 𝑖) + 𝑛 + (𝑛 − 1) + (𝑛 − 2) + ⋯ + (𝑛 − 𝑖 + 1)
After 𝑖 = 𝑛 − 1 iterations we have reached T(1).
𝑛 ⋅ (𝑛 + 1)
𝑇(𝑛) = 𝑇(1) + 2 + ⋯ + 𝑛 = Θ(1) +
− 1 = Θ(𝑛2 )
2
1
d. 𝑇(𝑛) = 𝑇 (𝑛2 ) + 1
Use iteration method:
1
𝑇(𝑛) = 𝑇 (𝑛2 ) + 1 =
1
1
1
1
= [𝑇 (𝑛4 ) + 1] + 1 = 𝑇 (𝑛2 ) + 2
= [𝑇 (𝑛8 ) + 1] + 2 = 𝑇 (𝑛8 ) + 3
…
1
1
= [𝑇 (𝑛2𝑖 ) + 1] + 𝑖 − 1 = 𝑇 (𝑛2𝑖 ) + 𝑖
After *𝑖 = log log 𝑛 iterations we have reached T(1).
1
𝑇(𝑛) = 𝑇 (𝑛2log log 𝑛 ) + log log 𝑛 = 𝑇(2) + log log 𝑛 = Θ(1) + log log 𝑛 = 𝑂(log log 𝑛)
𝑖
𝑖
* log log 𝑛 = 𝑖 ⇔ 2log log 𝑛 = 2𝑖 ⇔ log 𝑛 = 2𝑖 ⇔ 2log 𝑛 = 22 ⇔ 𝑛 = 22 ⇔
1
𝑖
𝑛2𝑖 = 2√𝑛 = 2
e. 𝑇(𝑛) = 2𝑇(𝑛 − 1) + 𝑂(1)
Use the iteration method:
𝑇(𝑛) = 2𝑇(𝑛 − 1) + 𝑂(1) =
= 2[2𝑇(𝑛 − 2) + 𝑂(1)] + 𝑂(1) = 4𝑇(𝑛 − 2) + 2 ⋅ 𝑂(1) + 𝑂(1) =
= 2[4𝑇(𝑛 − 3) + 𝑂(1)] + 2 ⋅ 𝑂(1) + 𝑂(1) = 8𝑇(𝑛 − 3) + 4 ⋅ 𝑂(1) + 2 ⋅ 𝑂(1) + 𝑂(1) =
…
= 2𝑖 𝑇(𝑛 − 𝑖) + 𝑂(1) ⋅ [1 + 2 + 4 + ⋯ + 2𝑛−1 ]
After 𝑖 = 𝑛 − 1 iterations we have reached T(1).
𝑇(𝑛) = 2𝑛−1 ⋅ 𝑇(1) + 𝑂(1) ⋅ (2𝑛−1 − 1) = Θ(2𝑛 )
Question 7:
𝑛
Given 𝑇(𝑛) = 16𝑇 (4 ) + 𝑓(𝑛), find a function 𝑓(𝑛) (if exists) such that the solution of T(n) is
equal to the written in the following sections.
Prove your answer for each section.
Following the Master theorem, 𝑛log𝑏 𝑎 = 𝑛2 . for 𝑓(𝑛) = Θ(1) the solution for 𝑇(𝑛) will be Θ(𝑛2 ),
so a solution for 𝑇(𝑛) will be at least Θ(𝑛2 ) for all 𝑓(𝑛) = Ω(1).
1) (𝑛 log 𝑛)
No solution.
(Note that the fact that there's no solution doesn't derive from the fact that we don't get a
solution from the master theorem – we know that there are cases for which the master
theorem doesn't hold – but because for 𝑓(𝑛) of the lowest possible order, the solution is
Θ(𝑛2 ).
2) (𝑛2 )
3
𝑛2
𝑛log𝑏 𝑎 = 𝑛log4 16 = 𝑛2
First case of the master theorem: 𝑓(𝑛) = 𝑂(𝑛log𝑏 𝑎−𝜖 ) = 𝑂(𝑛2−𝜖 ).
3
𝑓(𝑛) = 𝑛2
3) (𝑛2 ⋅ log 𝑛)
𝑛2
Second case of the master theorem: 𝑓(𝑛) = 𝑂(𝑛log𝑏 𝑎 ) = 𝑂(𝑛2 ).
𝑓(𝑛) = 𝑛2
4) (𝑛4 )
𝑛4
Third case of the master theorem: 𝑓(𝑛) = 𝑂(𝑛log𝑏 𝑎+𝜖 ) = 𝑂(𝑛2+𝜖 ).
𝑛
𝑛
𝑛 4
𝑛4
1
𝑎 ⋅ 𝑓 ( ) = 16 ⋅ 𝑓 ( ) = 16 ⋅ ( ) = 16 ⋅ 2 ≤ 𝑐 ⋅ 𝑛4 ⇒ 𝑐ℎ𝑜𝑜𝑠𝑒 𝑐 𝑠. 𝑡
≤𝑐<1
𝑏
4
4
16
16
𝑓(𝑛) = 𝑛4