Análise de Loops em Complexidade de Algoritmos

NOTE:
Eu sei que existe muito material sobre algoritmos na internet, mas eu acredito que essas minhas questões são cruciais para os iniciantes.

Para começar, imagine que nós temos os seguintes loops for() e while()

Linearsearch(arr, n, key)                                 
{                                                       
    i = 0;
    for(i = 0; i < n; i++)    // n + 1? or n?
    { 
        if(arr[i] == key)
        {
            printf(“Found”);
        }
}

i = 1;
sum = 0;        // Cost  Times
while (i <= n)  // c3    n + 1? or n?
{
    i += 1;
    sum += i;
}

• Por que os loops for() e while() tem o tempo "n + 1" e não apenas "n"?
• Em Python os loops for() e while() também são "n + 1"? Ou apenas "n"?

def linear_search(arr, n, key):  # (n + 1)? or (n)?
    for i in range(n):
        if arr[i] == key:
            print("Found")

i = 1
sum = 0
while i <= n:
    sum += i
    i += 1

O custo das instruções dentro dos loops for() e while() é "n" vezes ou seu custo específico?

Por exemplo, vamos considerar os seguintes loops for() e while():

def linear_search(data, value):
    for index in range(len(data)):
        if value == data[index]:
            return index
    raise ValueError('Value not found in the list')

i = 1;
sum = 0;
while (i <= n)
{
    i += 1;
    sum += i;
}

As instruções dentro dos loops tem sempre "n" custo ou depende? Isso porque eu vi em um tutorial na internet um caso em que as instruções dentro de um loop while tem tempo "n":

                // Cost  Times
i = 1;          // c1    1
sum = 0;        // c2    1
while (i <= n)  // c3    n + 1
{               //
    i += 1;     // c4    n
    sum += i;   // c5    n
}               //

def linear_search(data, value):     # Cost  Times
    for index in range(len(data)):  # c1    n
        if value == data[index]:    # c2    n
            return index            # c3    1 (or n?)
    raise ValueError('Value not found in the list')

• Veja que as instruções c4 e c5 do loop while() são "n" e não constantes(1). Por que?
• E a instrução c3 no loop for() é constante(1) e não "n"?

As instruções dentro dos loops são multiplicadas pelo número de iterações?

Para entender esta questão, vamos considerar o seguinte loop for():

def traverse(self):
    for index, _ in enumerate(self.arr):
        print(f"Index: {index}, Item: {self.arr[index]}")

• O loop "for" itera "n" vezes, então sua complexidade é O(n).
• Dentro do loop, a operação de impressão tem complexidade constante O(1).
• Como o loop se repete "n" vezes, o custo total se torna: n x O(1) = O(n).

A afirmação acima está correta?

Se a afirmação acima estiver correta, o loop aninhado abaixo será:

                        # Cost  Times
for row in matrix:      # c1    n
    for column in row:  # c2    n * n
        print(column)   # c3    1? or n?

So:

Total Cost = n + (n x n) + 1
           = n + n^2 + 1
           = O(n^2)