A complexidade do tempo de uma instrução `if` é geralmente o (1) , mas com algumas advertências importantes. Aqui está um colapso:

A ideia central:tempo constante

* A ramificação é rápida: A operação primária em uma instrução `if` está avaliando a condição e decidindo qual ramificação executar. Este é um processo determinístico muito rápido, envolvendo uma única comparação (ou uma série de operações booleanas que podem ser consideradas limitadas). Os processadores modernos são altamente otimizados para ramificação condicional.

* Independente do tamanho da entrada: A decisão de executar o bloco `if` ou o bloqueio` else` (ou não, se não houver `else`), não depende do tamanho dos dados de entrada que estão sendo processados ​​pelo algoritmo circundante. Depende apenas da própria condição.

Por que o (1) pode ser enganoso (o contexto é importante!)

Enquanto a instrução `if` * * é O (1), o código * * dentro do bloco` if` ou `else` pode ter qualquer complexidade de tempo. Isso é crucial. Considere estes cenários:

1. o (1) se bloco:

`` `Python
Se x> 5:
y =10 # O (1) atribuição
z =x + y # o (1) adição
outro:
y =20 # O (1) atribuição
`` `

Nesse caso, a instrução `if` e o código dentro * das duas * ramificações são O (1). A complexidade geral deste trecho é O (1).

2. o (n) se bloco:

`` `Python
Se Len (my_list)> 0:
para i em range (len (my_list)):# o (n) loop
print (my_list [i])
outro:
Print ("Lista está vazia") # O (1)
`` `

Aqui, se a condição for verdadeira, você executa um loop que itera através de `my_list`, tornando a complexidade do ramo` if` o (n). Se a condição for falsa, você executa o código O (1). A complexidade * pior dos casos * de todo esse bloco de código é O (n), porque a instrução `if` pode levar à execução do código O (n).

3. o (n^2) se bloco:

`` `Python
Se condição:
para i no intervalo (n):
Para J no intervalo (n):
# Alguma operação O (1)
passar
outro:
# O (1) Operação
passar
`` `
Neste exemplo, a complexidade do tempo se torna O (n^2) devido aos loops aninhados dentro da instrução `if`, mesmo que a avaliação da condição` if` ainda seja O (1).

em resumo

* A lógica de ramificação da declaração `if` é O (1).
* A complexidade total do tempo do código que contém a instrução `if` depende inteiramente da complexidade do código * dentro * dos blocos` if` e `else`. O bloco com a maior complexidade dominará.
* Ao analisar algoritmos, você precisa considerar o pior cenário, que geralmente envolve o bloqueio `if` com a maior complexidade sendo executada.

Portanto, enquanto você pode dizer a própria declaração `se` * * leva tempo constante, você deve Analise o código dentro das ramificações para determinar a verdadeira complexidade do tempo do bloco de código que contém o `if`. Concentre -se no termo dominante (o bloco de código que levará mais tempo para executar à medida que o tamanho da entrada cresce).