La complessità temporale di un ciclo while con tre puntatori diversi da 3 annidati per cicli?

Questo programma (scritto in ruby) trova i 3 numeri più grandi in un array (senza ordinare l'array). Ha un ciclo while con tre puntatori. Il mio istinto di pugno, dato che c'è un solo ciclo, è che questa soluzione è O (n). Ma i puntatori j e k vengono ripristinati quando raggiungono n, il che sembra lo stesso di usare 3 per cicli, quindi è O (n³)?

def greatest_of_3_with_ptrs(a)
  greatest = 0
  greatest_tuple = nil
  i,j,k=0,1,2
  n = a.length-1
  while( true) do
    sum = a[i]+a[j]+a[k]
    if sum > greatest then
      greatest = sum 
      greatest_tuple =[a[i],a[j],a[k]]
    end  
    sum = 0
    if k == n then
      j=j+1
      k=j+1
    else
      k+=1  
    end
    if j == n then
      i=i+1
      j=i+1
      k=j+1
    end
    break if k > n || j > n || i==n
  end
  { greatest_tuple: greatest_tuple, greatest: greatest }
end

a =[10,-1,4,2,5,3,0]
expected = 19
print greatest_of_3_ptrs(a)[:greatest] #> 19
print greatest_of_3_ptrs(a)[:greatest_tuple] #> [10,4,5]

Nota: sono a conoscenza della soluzione O (n), non è una mia domanda

def greatest(a)
  max_1,max_2,max_3 = a[0],a[1],a[2]  
  for i in 3..a.length-1
    if a[i] > max_1 then
      max_1 = a[i]
    elsif a[i] > max_2 then
      max_2 = a[i]
    elsif a[i] > max_3 then
      max_3 = a[i]
    end      
  end
  [max_1,max_2,max_3]
end