2. Evaluation and complexity of algorithms [1.4]

cin >> n;
sum = 0;
for (i=0; i<n; i++)
 for (j=0; j<n; j++) sum++;
 

 Input data size

* Let be a task in which the size of the input data is determined by an integer n.
* Almost all the tasks we will be looking at have this property.
* We will explain the latter by looking at a few examples:

Asymptotic notation

* When we are speaking about the complexity of an algorithm, we are most often interested in how it will work at a sufficiently large size n of the input data.
* When formally evaluating the complexity of algorithms, we examine their behavior at "sufficiently large" n.

1. O(f) defines the set of all functions g that grow no faster than f, i.e. there is a constant c > 0 such that g(n) <= cf(n) for all sufficiently large values ​​of n.

2. Theta(f) determines the set of all functions g that grows as fast as f (up to a constant factor), ie. there are constants c₁ > 0 and c₂ > 0 such that c₁f(n) <= g(n) <= c₁f(n) for all sufficiently large values ​​of n.

3. Omega(f) defines the set of all functions g that grow no slower than f, ie. there exists a constant c > 0 such that g(n)> = cf(n) for all sufficiently large values ​​of n.

O(f): Properties and examples

* Notation О(f) is the most commonly used in evaluating the complexity of algorithms and programs.
* More important properties of О(f) (~ denotes belong to):

Growth rate of commonly used functions:

** Determining the complexity of an algorithm.
* Finding the function that determines the relationship between the size of the input data and the runtime.
* We always look at the worst case - the worst case inputs.
- elementary operation - does not depend on the amount of data processed - O(1) ;
- operator sequence - is determined by the asymptotically slowest -  f + g ~ max(O( f ), O(g));
-operator composition - multiplication by complexity- f (g) ~ O( f*g);
- conditional operators - is determined by the asymptotically slowest between the condition and the different cases;
- loops, two nested loops, p nested cloops - O(n), O(n²), O(n^p) .

// 1
for (i = 0; i < n; i++)
 for (j = 0; j < n; j++, sum++);
// 2
for (i = 0; i < n; i++)
 for (j = 0; j < n; j++) if (a[i] == b[j]) return;
// 3
for (i = 0; i < n; i++)
 for (j = 0; j < n; j++) if (a[i] != b[j]) return;
// 4
for (i = 0; i < n; i++)
 for (j = 0; j < n; j++) if (a[i] == a[j]) return;
// 5
for (i = 0; i < n; i++)
 for (j = 0; j < i; j++) sum++;
// 6
for (i = 0; i < n; i++)
 for (j = 0; j < n*n; j++) sum++;
// 7
for (i = 0; i < n; i++)
 for (j = 0; j < i*i; j++) sum++;
// 8
for (i = 0; i < n; i++)
 for (j = 0; j < i*i; j++)
   for (k = 0; k < j*j; k++) sum++;

Logarithmic complexity

Let's look at the loop:
for (sum = 0, i = 0; i < n; i *= 2) sum++;
The variable i has values 1, 2, 4, ..., 2^k, ...  until it surpasses n. The loop is run [log n] times. The complexity is O(log n).

Calculation of recursion complexity
* Binary search in sorted array - recursive algorithm. 

int binary_search(vector<int> v, int from, int to, int a)
{  
   if (from > to)
      return -1;
   int mid = (from + to) / 2;
   if (v[mid] == a)
      return mid;
   else if (v[mid] < a)
      return binary_search(v, mid + 1, to, a);
   else
      return binary_search(v, from, mid - 1, a);
}

* We count the references to the elements of the array.
* The recursive function looks at the middle element and makes a recursive call with a twice smaller array.
* Therefore, if T(n) is the function that specifies the number of hits, then T(n) = T(n/2) + 1.
* From the equality
                T(n) = T(n/2) + 1 = T(n/4) + 2 = T(n/8) + 3 = ... = T(n/2^k) + k
we obtain for n = 2^k that  T(n) = T(1) + log n, i.e. the complexity of the algorithm is O(log n).

• the worst case
  
• the best case
  
• the average case