Un singur pas, orice dimensiune
O(1) înseamnă timp constant: operația face același număr de pași fie că intrarea are 5 elemente, fie un milion. Munca nu crește deloc.
Aceasta este cea mai bună complexitate care există. Operațiile O(1) tipice în Go sunt: citirea unui element dintr-un slice după index, citirea unei valori dintr-un map după cheie, len(), adăugarea unui singur element și calculele matematice simple.
Observă ce nu înseamnă O(1): nu înseamnă „rapid”, înseamnă „nu devine mai lent când crește intrarea”. Un singur pas constant poate fi în continuare un pas lent — dar rămâne un singur pas.
Căutări în slice și în map
Un element de slice se află la o poziție cunoscută în memorie, așa că words[2] este un singur salt — calculatorul nu parcurge elementele dinaintea lui. Aceeași citire costă la fel într-un slice cu un milion de elemente.
O căutare în map precum ages["Ben"] durează, în medie, tot timp constant: cheia îi spune map-ului direct unde este stocată valoarea. Căutarea returnează value, ok, iar ok este false când cheia lipsește.
Citirea unui element după index
Programul citește un element dintr-un slice cu 5 elemente și un element dintr-un slice cu un milion de elemente. Ambele citiri sunt un singur pas — lungimea slice-ului nu joacă niciun rol.
Ieșire: program Go și rezultatul capturat
package main
import "fmt"
func main() {
words := []string{"one", "two", "three", "four", "five"}
big := make([]int, 1000000)
for i := range big {
big[i] = i * 2
}
// Câte un singur pas, indiferent cât de lung este slice-ul.
fmt.Println(words[2])
fmt.Println(big[999999])
}
Citirea unei valori după cheie
ages["Ben"] găsește direct 25. Cheia lipsă "Dan" returnează valoarea zero 0 și ok == false — tot în timp constant.
Ieșire: program Go și rezultatul capturat
package main
import "fmt"
func main() {
ages := map[string]int{"Ana": 30, "Ben": 25, "Cleo": 41}
age, ok := ages["Ben"]
fmt.Println(age, ok)
age, ok = ages["Dan"]
fmt.Println(age, ok)
}
Adăugarea și calculele simple
append() adaugă un element la sfârșitul unui slice. De cele mai multe ori acesta este un singur pas. (Din când în când slice-ul trebuie să crească și este copiat, dar, la medie, costul unui append rămâne constant.)
Toate operațiile mici — atribuiri, adunări, comparații, interschimbarea a două valori — sunt și ele O(1). Ele sunt „pașii” în care se numără toate celelalte clase de complexitate.
Adăugarea unui element
append() pune "galben" la sfârșit. Costul nu depinde de câte culori sunt deja în slice.
Ieșire: program Go și rezultatul capturat
package main
import "fmt"
func main() {
colors := []string{"roșu", "verde", "albastru"}
fmt.Println("înainte:", colors, "lungime:", len(colors))
colors = append(colors, "galben")
fmt.Println("după: ", colors, "lungime:", len(colors))
}
Interschimbarea a două valori
a, b = b, a interschimbă cele două valori într-un singur pas cu timp constant — fără să fie nevoie de o variabilă ajutătoare.
Ieșire: program Go și rezultatul capturat
package main
import "fmt"
func main() {
a, b := 1, 2
fmt.Println("înainte:", a, b)
a, b = b, a
fmt.Println("după: ", a, b)
}