Algoritmo

Um algoritmo é uma lista de passos que devem ser seguidos para executar uma tarefa. O termo algoritmo costuma ser usado em referência a programação de computadores pois todo programa de computador não passa de um algoritmo que o computador segue para processar dados de uma maneira ou de outra. Entretanto, algoritmos podem ser seguidos por nós seres humanos também.

Todo algoritmo possui algum objetivo. Por exemplo, um algoritmo para "ir dormir" poderia ser:

1. Escovar os dentes.
2. Apagar as luzes.
3. Ir para cama.
4. Fechar os olhos.

Os passos de um algoritmo são seguidos na ordem exata em que são escritos. Você pode pensar: por que que eu não posso apagar as luzes primeiro e ir escovar os dentes no escuro? Mas a resposta no caso é simplesmente que escovar é o passo número 1, e apagar as luzes é o passo número 2.

Quando um programa de computador executa um algoritmo, ele sempre o executa na mesma ordem. Se a ordem parece diferente as vezes, é simplesmente por que o algoritmo é tão complexo que o algoritmo é capaz decidir a ordem de suas etapas.

Controle de Fluxo

Existem apenas duas estruturas de algoritmos que precisamos entender para entendermos como todo algoritmo de computador funciona: passos condicionais e "ir para" passos.

Se

Passos condicionais são passos que não são executados (são pulados) em certos casos. Chamamos o caso de condição, i.e. ele só é executado sob determinadas condições. Por exemplo:

1. Trancar a porta.
2. Se estiver chovendo: pegar o guarda-chuva.
3. Ir para escola.

Se executarmos o algoritmo acima, só pegaremos o guarda-chuva se estiver chovendo, nos dias que está fazendo sol, o passo número 2 será pulado.

Passos "ir para" são passos que, quando executados, mudam qual o próximo passo da lista que devemos executar. Existem várias maneiras com que esses passos podem ser usados.

Primeiro, pular vários passos de uma vez só.

1. Trancar a porta.
2. Se não estiver chovendo: ir para o passo 6.
3. Tirar a roupa do varal.
4. Pegar o guarda chuva.
5. Tomar cuidado ao descer a escada.
6. Ir para escola.

Acima, conseguimos pular 3 passos executando um passo condicional apenas. Isto é, em efeito, os passos de 3 a 5 se tornaram condicionais também, já que sua execução depende da não-execução do passo 2. Nosso algoritmo ficou bem complicado, mas podemos complicar ele ainda mais.

Senão

1. Trancar a porta.
2. Se não estiver chovendo: ir para o passo 7.
3. Tirar a roupa do varal.
4. Pegar o guarda chuva.
5. Tomar cuidado ao descer a escada.
6. Ir para o passo 8.
7. Pegar a sombrinha.
8. Ir para escola.

No algoritmo acima, quando está chovendo, os passos 1, 3, 4, 5, 6, e 8 são executados. Quando não está chovendo, os passos 1, 2, 7, e 8 são executados.

           1 2 3 4 5 6 7 8
Se chover: x   x x x x   x
Senão:     x x         x x 

Em linguagens de programação, o código para criar um algoritmo desse jeito costumar usar duas estruturas diferentes: uma para "se" (if), e uma para "senão" (else), cada uma com sua própria lista de algoritmos.

trancar_a_porta;

se esta_chovendo:
    tirar_a_roupa_do_varal;
    pegar_o_guarda_chuva;
    tomar_cuidado_ao_descer_escada;
senão:
    pegar_a_sombrinha;

ir_para_escola;

Existem linguagens de programação que suportam o "ir para" (go to), tais como C, porém geralmente o "ir para" não é necessário já que existem outros meios mais claros de se escrever o mesmo algoritmo, e com isso seu uso não é nem recomendado.

Loop

Outra situação encontrada em algoritmos são loops ("lupis," significado "voltas" dada ao redor de algo, ou algo no formato de um circulo). Loops ocorrem quando um passo "ir para" manda o executor ir para um passo antes do passo "ir para," o que significa que se o executor seguir os mesmos passos da última vez, ele irá parar no mesmo "ir para trás," voltar para trás de novo, e isso irá se repetir infinitamente.

1. Acordar.
2. Trabalhar.
3. Dormir.
4. Ir para o passo 1.

Brecha de Loop

Para sairmos de um loop infinito, basta tornar o passo que nos manda para trás em um passo condicional.

1. Bater na porta.
2. Se não atender, ir para o passo 1.
3. Falar "bom dia."

Mas pera aí, e se a pessoa nunca atender a porta? Vamos revisar esse algoritmo.

1. Se tivermos batido na porta 5 vezes, ir para o passo 6.
2. Bater na porta.
3. Se não atender, ir para o passo 1.
4. Falar "bom dia."
5. Para a execução do algoritmo.
6. Desistir e ir embora.

O formato desse algoritmo pode parecer meio estranho, mas estranhamente é assim que grande parte dos loops é programado. Em C, poderíamos escrever um código parecido assim:

int main() {
    for(int batidas = 0; batidas < 5; batidas++) {
        bater_na_porta();
        if(porta_foi_atendida()) {
            goto falar_oi;
        }
    }
    desistir_e_ir_embora();
    return 0;
    falar_oi:
    falar("Bom dia.");
}

Se você sabe alguma coisa de programação você pode considerar o código acima muito feio. Afinal de contas, existem jeitos muito mais elegantes de escrever esse algoritmo em código C. Por que que uma pessoa que escreve um código tão bonito como eu está escrevendo um código tão feio quanto esse acima? É por que esse código é mais próximo de como algoritmos são executados por um computador.

A CPU executa um tipo de código chamado de código de máquina (machine code). Esse código são simplesmente bytes enfileirados. Isto é, não existe "se" e "senão." Em vez disso, existe um operador para comparar dois valores, e um operador para "ir para" outro byte do código máquina se o resultado da comparação for verdadeira. Isto é, o código que a CPU executa é uma simples lista de passos no formato de bytes, da mesma forma que as listas complicadas que vemos nesse artigo, exceto que extremamente mais complexas.