Busca linear ou busca sequencial

A busca linear ou busca sequencial é a forma mais simples de se buscar um resultado em uma lista de dados. O vetor é percorrido comparando cada dado do vetor até encontrar o resultado desejado e retornando o índice do valor encontrado. O dado a ser encontrado é passado como parâmetro para função. O melhor caso nessa situação é se o dado que está sendo procurando é a primeira opção do vetor, e o pior resultado ocorre se este for o ultimo dado do vetor. A complexidade da busca linear é O(n).
Abaixo a implementação desse algoritmo e sua chamada:

#define TAM 10

int buscaLinear(int tamanho, int vetor[], int valor)
{
    int i;
    for(i = 0; i < tamanho; i++)
        if(vetor[i] == valor)
            return i;
        else if(i == tamanho-1)
            return -1;
}

int main(int argc, char *argv[])
{
    int indice, v[TAM] = {9,7,5,2,4,6,10,3,1,8};
    indice = buscaLinear(TAM, v, 6); //chamando a função de busca
    printf("Valor esta na posicao %d", indice);
    getch();
    return 0;
}

Veja também o artigo sobre Busca binária.

Linguagem C: Laço de repetição do / while

A diferença do "do/while" para o laço "while" é que a condição e verificada no final de sua estrutura. Dessa forma ele sempre vai executar, pelo menos, uma vez.
Exemplo:

main()
{
      int i = 10;
      do{
          printf("O laco do-while eh executado pelo menos uma vez.");
      }while(i < 10);
      getch();
      return 0;
}

Observe no código acima que mesmo o contador "i" já estando em 10 o laço ainda imprimiu a linha uma vez (Observe sua condição no final da estrutura na linha 6).
Um exemplo muito útil é um menu em linguagem C. O menu deve aparecer na tela independente da condição, obviamente, e o usuário escolhe a seguir a opção que deseja executar:

main()
{
      char op;
      do{
          system("cls"); //limpar tela (windows)
          printf("1- Opcao 1 \n2- Opcao 2 \n3- Opcao 3 \n0- Sair\n");
          op = getch();
          switch(op)
          {
               case '1': 
                    system("cls");
                    printf("Voce escolheu a opcao 1\n");
                    getch(); break;
               case '2': 
                    system("cls");
                    printf("Voce escolheu a opcao 2\n"); 
                    getch(); break;
               case '3': 
                    system("cls");
                    printf("Voce escolheu a opcao 3\n"); 
                    getch(); break;
               case '0': return 0;
               default: printf("Opcao invalida!\n");
          }
      }while(op != 0);
      getch();
      return 0;
}

Obviamente as dentro de cada caso do switch deveríamos substituir pelas instruções da opção escolhida pelo usuário. Faça o teste: substitua no código acima as instruções para criar uma calculadora que faça soma, divisão, subtração e multiplicação. Crie as variáveis necessárias e substitua o nome das opções.

Linguagem C: Laço de repetição while

O laço de repetição "while" é semelhante ao laço for. A diferença é que em sua sintaxe informamos apenas a condição:

main()
{
    int i = 0;
    while(i < 10)
    {
        printf("%d, ", i);
        i++;
    }
    getch();
    return 0;
}

Devemos ter cuidado para não criar laços de repetição que nunca atingirão a condição.
Observe que esse simples laço de repetição acima pode ser criado também com for.
Então, quando usar o "while" e quando usar o "for"?
Como observamos, no "while" não definimos o valor de um contador e seu fim. Isso será definido através dos comandos e cálculos que serão executados dentro de sua estrutura ou que serão informados pelo usuário. Por ter essa característica, podemos usa-lo quando não conhecemos o fim da execução do laço.
Exemplo:
Criar um programa que diga para o usuário quantos meses ele precisará para guardar uma determinada quantia de dinheiro.

main()
{
    float qnttotal, qntmes;
    int totalmeses = 1;
    printf("Informe o total que deseja guardar: ");
    scanf("%f",&qnttotal);
    printf("Informe quanto ira guardar por mes: ");
    scanf("%f",&qntmes);
    while((qntmes * totalmeses) < qnttotal)
        totalmeses++;
    printf("Sera necessario %d meses", totalmeses);
    getch();
    return 0;
}

Linguagem C: Laço de repetição for

Com o laço de repetição "for" podemos criar um bloco que será repetido enquanto uma determinada condição não for alcançada.
Podemos dessa forma evitar digitar código extensos. Imaginem, por exemplo, que você precisa digitar 20 vezes a mesma linha. Digitar 20 vezes o printf() com a linha que quer imprimir não é a melhor solução. Aumente isso para 50, pra 100, nada viável digitar tantas linhas para fazer a mesma coisa.
Podemos fazer com que o mesmo bloco repita pela quantidade de vezes que desejamos:

main()
{
    int i;
    for(i = 0; i < 20; i++)
        printf("Linha %d\n", i+1);
    getch();
    return 0;
}

No exemplo acima sera impresso:
"Linha 1"
Como o contador ainda não chegou em seu limite é incrementado 1 ao valor de i e impresso:
"Linha 2"
"Linha 3"
...
"Linha 20"
No momento da impressão é somando 1 ao valor do contador i por que ele começa em 0. O laço é executado de 0 a 19.
O laço for é formado por três partes:
for(inicio da variável ; enquanto <condição> ; incremento)
Podemos ler o for(i = 0; i < 20; i++) da seguinte forma:
para( i começando em 0 ; enquanto i for menor que 20 ; incrementar i de 1 em 1)
Deve-se tomar muito cuidado ao usar laços de repetições, pois pode-se criar laços infinitos. Ou seja, nunca será atingida a condição para parada do laço.
Quando o for possuir mais de uma linha em sua estrutura há a necessidade de inserir chaves para definir o inicio e o fim da estrutura do for. Exemplo:

main()
{
    int i;
    for(i = 0; i < 20; i++)
    {
        if((i+1) % 2 == 0)
            printf("Linha %d\n", i+1);
    }
    getch();
    return 0;
}

Laço for aninhado

For aninhado é o uso de um for dentro de outro. Quando isso ocorre o laço que está mais interno é executado até o fim para depois voltar a mais externo e repetir o laço interno novamente. De modo mais simples, oque estaremos fazer é repetir uma repetição.

Exemplo:

main()
{
    int i, j;
    for(i = 0; i < 5; i++)
        for(j = 0; j < 3; j++)
            printf("i=%d E j=%d\n", i, j);
    getch();
    return 0;
}

Ao entrar no primeiro for o i é 0 (i=0) logo em seguida o programa já entra em outro laço de repetição onde o j é 0 (j=0) e imprime:
i=0 E j=0
E volta para o for mais interno e incremento 1 no j (j=1) e imprime:
i=0 E j=1
Observe que não saímos da primeira repetição do for do contador i. Será feita toda repetição do for do contato j para depois incrementar em e i e novamente fazer o for do contador j de 0 a 2 e assim até finalizar as 5 repetições do primeiro for.
Veja o resultado:

Bastar multiplicar a quantidade de repetições do primeiro laço (5) com a quantidade de repetições do segundo (3) e descobrimos quantas vezes será executada a instrução: 5 * 3 = 15.