Question

what is runing time of Algo1 in Θ-notation?

Answer 1

1.The running time of an algorithm is the number of instructions it executes in the RAM(Random access memory) model of computation.

2.Θ-notation is used to give asymptotically tight bounds.Since, it represents the upper and the lower bound of the running time of an algorithm,it is used for analyzing the average case complexity of an algorithm.

Let's take a simple implementation of linear search to understand better.

1. int linearSearch(const vector<int>& array,

2. const int targetValue) {

3.for (int guess = 0; guess < array.size(); guess++) {

4.if (array[guess] == targetValue) {

5.return guess;  

6.}

7.} return -1;  

8.}

Let's denote the size of the array by n. The maximum number of times that the for-loop can run is n, and this worst case occurs when the value being searched for is not present in the array. Each time the for-loop iterates, it has to do several things: compare guess with n; compare array[guess] with targetValue; possibly return the value of guess; and increment guess. Each of these little computations takes a constant amount of time each time it executes. If the for-loop iterates n times, then the time for all n iterations is c₁⋅n, where c₁ is the sum of the times for the computations in one loop iteration. Now, we cannot say here what the value of c₁ is, because it depends on the speed of the computer, the programming language used, the compiler or interpreter that translates the source program into runnable code, and other factors. This code has a little bit of extra overhead, for setting up the for-loop (including initializing guess to 0) and possibly returning -1 at the end. Let's call the time for this overhead c₂, which is also a constant. Therefore, the total time for linear search in the worst case is c₁⋅n + c₂.

As we've argued, the constant factor c₁ and the low-order term c₂ don't tell us about the rate of growth of the running time. What's significant is that the worst-case running time of linear search grows like the array size n.

The notation we use for this running time is Θ(n) or Theta notation.

When we say that a particular running time is Θ(n), we're saying that once n gets large enough, the running time is at least k₁⋅n and at most k₂⋅n for some constants k₁ and k₂. Here's how to think of Θ(n):

figure : 1 Kzon gumIAX timel Kion

For small values of n, we don't care how the running time compares with k₁⋅n or k₂⋅n. But once n gets large enough—on or to the right of the dashed line—the running time must be sandwiched between k₁⋅n and k₂⋅n. As long as these constants k₁ and k₂ exist, we say that the running time is Θ(n).

Figure : 2 Kr.fo) running time

Once n gets large enough, the running time is between k₁⋅f(n) and k₂⋅f(n).

In practice, we just drop constant factors and low-order terms. Another advantage of using big-Θ notation is that we don't have to worry about which time units we're using. For example, suppose that you calculate that a running time is 6n² + 100n + 3006 microseconds. Or maybe it's milliseconds. When you use big-Θ notation, you don't say. You also drop the factor 6 and the low-order terms 100n + 300, and you just say that the running time is Θ(n²).