Analyzing Runtime Complexity Of Algorithms Using Big O Notation

Number of the operations for the best, worst and average cases for all the six algorithms are described below:

The best case is 1.

The worst case is 7.

The average case is 4.

The best case is 0.

The worst case is N

The average case is i+1+.../N>= i

The best case is N (N+1) / 2

The Worst case is 1+2+…N = N(N+1) / 2

The average case N(N+1) / 2

The best case is 2logN

The worst case is 2logN

The average case is 2logN

The best case is 0

The worst case is 2N

The average case is N.

The best case is 0

The worst case is N(N-1) /2

The average case is (N-1)/2.

The best, worst and average case using Big-Θ notation are as follows:

• Best case: There is a total of 9 operations for best case, So Big Θ notation of the best case = Θ (1).
• Worst Case: There is a total of 14 operations for the Worst case, So Big Θ notation of the Worst case = Θ (1).
• Average case: There is a total of 11 operations for the Average case, So Big Θ notation of the average case = Θ (1).

1. The overall performance of each algorithm using the tightest possible class in Big-O notation are as follows:

For algorithm 1 = O(1)

For algorithm 2= O(n)

For algorithm 3 = O(n^2)

For algorithm 4 = O(logn)

For algorithm 5 = O(n)

For algorithm 6 = O(n^2)

1. The overall performance of each algorithm using the tightest possible class in Big- Ω notation are as follows:

For algorithm 1 = Ω (1)

For algorithm 2= Ω (n)

For algorithm 3 = Ω (n)

For algorithm 4 = Ω (1)

For algorithm 5 = Ω (n)

For algorithm 6 = Ω (n)

1. The overall performance of each algorithm using Big- Θ notation are as follows:

For algorithm 1 = O (1)

For algorithm 2= O (n)

For algorithm 3 = O (n²)

For algorithm 4 = O(log ₂ N)

For algorithm 5 = 2O (n)

For algorithm 6 = O(n²)

1. Big-O is the best way to describe the performance of each algorithm is by using big Oh notation. It measures the time taken by the program to execute in the worst-case scenario.

Big O notation is used to describe the runtime of any algorithm. It helps in comparing different program to identify which is better. It provides an upper bound for the runtime of an algorithm. In other words, Big O notation helps to identify how any algorithm or program reacts in being scaled that is driven to solve complex problems.

For example: if the program scales linearly. That is, O(n) slows proportionally to the given input.

No, θ(n³) will not always take longer to run as compared to θ(logn). Because θ(logn)  always perform faster as compared any other θ(n³).

T(n) = 2n² + 6¹³n

While finding Big-O of any given function, It is essential to find the degree of variables.

n² > n

And in Big-O or any asymptotic notation, constants are ignored.

Therefore, Big-O of T(n) = O(n²) is right.

T(n) = nlogn

Here is the order only for Big-O

logn < n < n.logn < n² < n³ < .....

The Big O of T(n) = O(n.logn) but not O(n)

Here, n and logn are in multiplication. Therefore, both must be included. If we had T(n) = n + logn, then we would have got O(n) only

Therefore, T(n) = O(n) is Wrong.

F(n) = n³ +n² + 10⁶n

If c₁ g(n) <= f(n) <= c₂ g(n)

n³ +n² + 10⁶n <= c₂ (n⁴)

but n³ +n² + 10⁶n <= c₁ (n⁴) will not be able to satisfy the larger values thus it is Wrong.

nlog(n) =  (n)

f(n) = nlog (n)

if n log(n)>=c(n) it is true  and n log(n) >= n it is also right.