Asymptotic Analysis: Understanding Infinite Limits

introduction
If you've ever studied software development and software analysis, you've undoubtedly come across the question, "Is my code good? Is it efficient?" To answer this question, we need to master asymptotic analysis.

Asymptotic Notation
Starting with the fundamentals of Asymptotic Notation, we need to master "Big O." The "Big O" notation is defined as O(f(n)), where "f(n)" is a function that describes the upper bound of the growth of another function. This allows us to compare the performance of algorithms as their inputs grow indefinitely.

Exist five main functions in the "Big O", in which will be explain how to indentify them:

O(1) : this denotes a constant time of execution, this means that the function does not depends on the size of the input.

O(log n) : indicates logarithmic growth

O(n) : represents linear growth, when the time of execution is directly proportional to the size of the input

O(n log n) : Common in efficient sorting algorithms.

O(n²) : Indicates quadratic growth, common in inefficient algorithms, such as some forms of selection sort.

To explain how to use it in practice, I will use the following example.

function buscaLinear(array, alvo) {
  for (let i = 0; i < array.length; i++) {
    if (array[i] === alvo) {
      return i; // Elemento encontrado
    }
  }
  return -1; // Elemento não encontrado
}

First step:
Considering the provided code, the first step is to identify which functions exist and create a notation that describes how many steps are required to execute the algorithm.

In this simple case, we can identify that there is a loop that will iterate through a specific array, making it a linear growth notation T(n) because the increase in steps is directly proportional to the number of objects in the array.

Second step:
The second step to perform asymptotic analysis is the simplification of the equation we created in the previous step. Simplification involves removing all elements from the notation except the largest variable. Therefore, the complexity of T(n) is O(n).

Conclusion:
In summary, mastering asymptotic analysis, especially the "Big O" notation, is essential for software development professionals. This skill enables a thorough evaluation of algorithm performance and guides decisions regarding algorithm selection and optimization. Understanding algorithm growth rates is fundamental for creating efficient and scalable software systems. Asymptotic analysis is a valuable tool that empowers developers to write better and more efficient code.