O documento descreve o algoritmo de ordenação bubble sort, explicando como ele funciona para ordenar vetores de maneira crescente ou decrescente. O bubble sort compara elementos adjacentes em um vetor e troca seus valores caso estejam fora de ordem. O documento fornece um exemplo passo a passo do algoritmo ordenando um vetor de maneira crescente.

1. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 1 de 18
BUBBLE SORT
Bubble Sort é um algoritmo de ordenação que pode ser aplicado em Arrays e Listas
dinâmicas. Se o objetivo é ordenar os valores em forma decrescente, então, a posição atual é
comparada com a próxima posição e, se a posição atual for maior que a posição posterior, é
realizada a troca dos valores nessa posição. Caso contrário, não é realizada a troca, apenas
passa-se para o próximo par de comparações.
Se o objetivo é ordenar os valores em forma crescente, então, a posição atual é
comparada com a próxima posição e, se a posição atual for menor que a posição posterior, é
realizada a troca. Caso contrário, a troca não é feita e passa-se para o próximo par de
comparação.
Um array ou lista pode estar já ordenado no momento em que se solicita a ordenação,
dessa forma, esta situação tem de ser considerada na implementação do algoritmo. Assim,
demonstrarei a representação gráfica e o teste de mesa das duas situações usando array.
1. VETOR DESORDENADO
Suponha o seguinte vetor chamado V:
Índice 0 1 2 3 4
elemento 200 10 0 5 30
posição i i+1 i+2 i+3 i+4
Vamos utilizá-lo para analisar e testar o comportamento deste algoritmo. Apenas
reforçando que em Linguagem C o vetor começa na posição 0. Utilizamos o comando de controle
FOR para manipular vetores, então, aqui implementaremos um for que irá da posição 0 até a
posição 4 e será incrementado de 1, iniciando em zero. Dessa forma conseguimos obter o valor
dos elementos das posições que serão comparadas usando o comando de controle IF e,
conforme a ordem desejada fazer a troca se for necessária.
Para que não ocorra repetição desnecessária, utilizaremos uma FLAG, que nos avisará
quando o vetor estará ordenado e, assim, a execução será terminada. Essa FLAG sempre será
setada com 1 quando houver uma troca. Dessa forma, enquanto n for menor ou igual ao tamanho
do vetor e, ao mesmo tempo a FLAG for igual a 1, então, deve-se continuar ordenando, caso
contrário, o vetor estará ordenado.

2. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 2 de 18
1.1. ORDENANDO DE FORMA CRESCENTE
1.ª Passagem no While:
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 0 5 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[0] >= V[1]
200 >= 10
V
aux = V[i]
aux = V[0]
aux = 200
V[i] = V[i+1]
V[0] = V[1]
V[0] = 10
V[i+1] = aux;
V[1] = aux;
V[1] = 200
Estado do vetor após a troca:
0 1 2 3 4
10 200 0 5 30
i i+1 i+1 i+1 i+1
i = 1; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
10 200 0 5 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[1] >= V[2]
200 >= 0
V
aux = V[i]
aux = V[1]
aux = 200
V[i] = V[i+1]
V[1] = V[2]
V[1] = 0
V[i+1] = aux;
V[2] = aux;
V[2] = 200
Estado do vetor após a troca:
0 1 2 3 4
10 0 200 5 30
i i+1 i+1 i+1 i+1
i = 2; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
10 0 200 5 30
i i+1 i+1 i+1 i+1

3. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 3 de 18
Verifica Troca = 1
V[i] >= V[i+1]
V[2] >= V[3]
200 >= 5
V
aux = V[i]
aux = V[2]
aux = 200
V[i] = V[i+1]
V[2] = V[3]
V[2] = 5
V[i+1] = aux;
V[3] = aux;
V[3] = 200
Estado do vetor após a troca:
0 1 2 3 4
10 0 5 200 30
i i+1 i+1 i+1 i+1
i = 3; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
10 0 5 200 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[3] >= V[4]
200 >= 30
V
aux = V[i]
aux = V[3]
aux = 200
V[i] = V[i+1]
V[3] = V[4]
V[3] = 30
V[i+1] = aux;
V[4] = aux;
V[4] = 200
Estado do vetor após a troca:
0 1 2 3 4
10 0 5 30 200
i i+1 i+1 i+1 i+1
i = 4; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
10 0 5 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[4] >= V[5]
200 >= ?
F
Chegamos ao fim do Vetor com o FOR, entretanto, ele ainda NÃO está ordenado de forma
crescente. Portanto, a execução do While continua.
2.ª Passagem no While
i = 0; troca = 1;

4. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 4 de 18
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
10 0 5 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[0] >= V[1]
10 >= 0
V
aux = V[i]
aux = V[0]
aux = 10
V[i] = V[i+1]
V[0] = V[1]
V[0] = 10
V[i+1] = aux;
V[1] = aux;
V[1] = 10
Estado do vetor após a troca:
0 1 2 3 4
0 10 5 30 200
i i+1 i+1 i+1 i+1
i = 1; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 10 5 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[1] >= V[2]
10 >= 5
V
aux = V[i]
aux = V[1]
aux = 10
V[i] = V[i+1]
V[1] = V[2]
V[1] = 5
V[i+1] = aux;
V[2] = aux;
V[2] = 10
Estado do vetor após a troca:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
i = 2; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[2] >= V[3]
10 >= 30
F

5. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 5 de 18
i = 3; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[3] >= V[4]
30 >= 200
F
i = 4; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] >= V[i+1]
V[4] >= V[5]
200 >= ?
F
Chegamos ao fim do Vetor com o FOR, entretanto, apesar do vetor já estar ordenado de
forma crescente, é preciso ainda que o WHILE passe mais uma vez pois TROCA ainda vale 1.
A confirmação de que o vetor está ordenado será dado TROCA for setado como zero. Como o
vetor está ordenado, então, o FOR correrá todas as posições, mas não entrará no IF, que é o
onde TROCA é setada como 1.
3.ª Passagem no While
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[0] >= V[1]
0 >= 5
F

6. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 6 de 18
i = 1; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[1] >= V[2]
5 >= 10
F
i = 2; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[2] >= V[3]
10 >= 30
F
i = 3; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[3] >= V[4]
30 >= 200
F
i = 4; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[4] >= V[5]
200 >= ? F

7. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 7 de 18
O algoritmo terminou de executar, troca é igual a 0, portanto o vetor está ordenado.
1.1.1. CÓDIGO FONTE
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
void imprimir();
int i, aux, troca, numero[5];
int main()
{
setlocale(LC_ALL, "Portuguese");
printf("n--------------------------------------------");
printf("nEXEMPLO BUBBLE SORT CRESCENTE");
printf("n--------------------------------------------");
printf("nInicializando o Array");
for(i=0; i<5; i++)
{
numero[i] = 0;
}
imprimir();
printf("n--------------------------------------------");
printf("nInserindo valores no Arrayn");
for(i=0; i<5; i++)
{
printf("n|Posição %d |Digite um número: t", i);
scanf("%d%*c",&numero[i]);
}
printf("n--------------------------------------------");
printf("nValores armazenados no array");
imprimir();
printf("n--------------------------------------------");
printf("nOrdenando o Array");
troca = 1;
while (troca == 1)
{
troca = 0; for (i = 0; i <= 3; i++)
{
if (numero[i] > numero[i + 1])
{
troca = 1;
aux = numero[i];
numero[i] = numero[i + 1];
numero[i + 1] = aux;
}

8. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 8 de 18
}
}
printf("n--------------------------------------------");
printf("nValores ordenados");
imprimir();
printf("n--------------------------------------------");
return 0;
}
void imprimir()
{
printf("n--------------------------------------------");
for (i=0; i<5; i++)
{
printf("n|Posicao: %d | Número: %d|", i, numero[i]);
}
}
1.2. ORDENANDO DE FORMA DECRESCENTE
1.ª Passagem no While
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 0 5 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[0] <= V[1]
200 <= 10
F
i = 1; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 0 5 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[1] <= V[2]
10 <= 0
F

9. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 9 de 18
i = 2; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 0 5 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[2] <= V[3]
0 <= 5
V
aux = V[i]
aux = V[2]
aux = 0
V[i] = V[i+1]
V[2] = V[3]
V[2] = 5
V[i+1] = aux;
V[3] = aux;
V[3] = 0
Estado do vetor após a troca:
0 1 2 3 4
200 10 5 0 30
i i+1 i+1 i+1 i+1
i = 3; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 5 0 30
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[3] <= V[4]
0 <= 30
V
aux = V[i]
aux = V[3]
aux = 0
V[i] = V[i+1]
V[3] = V[4]
V[3] = 30
V[i+1] = aux;
V[4] = aux;
V[4] = 0
Estado do vetor após a troca:
0 1 2 3 4
200 10 5 30 0
i i+1 i+1 i+1 i+1
i = 4; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 5 30 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[4] <= V[5]
30 <= ?
F

10. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 10 de 18
Chegamos ao fim do Vetor com o FOR, entretanto, ele ainda NÃO está ordenado de forma
crescente. Portanto, a execução do While continua.
2.ª Passagem no While
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 5 30 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[0] <= V[1]
200 <= 10
F
i = 1; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 5 30 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[1] <= V[2]
10 <= 5
F
i = 2; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 5 30 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[2] <= V[3]
5 <= 30
V
aux = V[i]
aux = V[2]
aux = 5
V[i] = V[i+1]
V[2] = V[3]
V[2] = 30
V[i+1] = aux;
V[3] = aux;
V[3] = 5
Estado do vetor após a troca:
0 1 2 3 4
200 10 30 5 0
i i+1 i+1 i+1 i+1

11. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 11 de 18
i = 3; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 30 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[3] <= V[4]
5 <= 0
F
i = 4; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 30 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[4] <= V[5]
0 <= ?
F
Chegamos ao fim do Vetor com o FOR, entretanto, ele ainda NÃO está ordenado de forma
crescente. Portanto, a execução do While continua.
3.ª Passagem no While
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 10 30 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[0] <= V[1]
200 <= 10
F
i = 1; troca = 1;
Estado do vetor e posições a serem comparadas:

12. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 12 de 18
0 1 2 3 4
200 10 30 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[1] <= V[2]
10 <= 30
V
aux = V[i]
aux = V[1]
aux = 10
V[i] = V[i+1]
V[1] = V[2]
V[1] = 30
V[i+1] = aux;
V[2] = aux;
V[2] = 10
Estado do vetor após a troca:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
i = 2; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[2] <= V[3]
10 <= 5
F
i = 3; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 1
V[i] <= V[i+1]
V[3] <= V[4]
5 <= 0
F
i = 4; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1

13. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 13 de 18
Verifica Troca = 1
V[i] <= V[i+1]
V[4] <= V[5]
0 <= ?
F
Chegamos ao fim do Vetor com o FOR, entretanto, apesar do vetor já estar ordenado de
forma crescente, é preciso ainda que o WHILE passe mais uma vez pois TROCA ainda vale 1.
A confirmação de que o vetor está ordenado será dado TROCA for setado como zero. Como o
vetor está ordenado, então, o FOR correrá todas as posições, mas não entrará no IF, que é o
onde TROCA é setada como 1.
4.ª Passagem no While
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[0] <= V[1]
200 <= 30
F
i = 1; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[1] <= V[2]
30 <= 10
F
i = 2; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1

14. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 14 de 18
Verifica Troca = 0
V[i] <= V[i+1]
V[2] <= V[3]
10 <= 5
F
i = 3; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[3] <= V[4]
5 <= 0
F
i = 4; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[4] <= V[5]
0 <= ?
F
O algoritmo terminou sua execução, troca é igual a zero, o vetor está ordenado.
1.2.1. CÓDIGO FONTE
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <string.h>
void imprimir();
int i, aux, troca, numero[5];
int main()
{
setlocale(LC_ALL, "Portuguese");
printf("n--------------------------------------------");
printf("nEXEMPLO BUBBLE SORT CRESCENTE");

15. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 15 de 18
printf("n--------------------------------------------");
printf("nInicializando o Array");
for(i=0; i<5; i++)
{
numero[i] = 0;
}
imprimir();
printf("n--------------------------------------------");
printf("nInserindo valores no Arrayn");
for(i=0; i<5; i++)
{
printf("n|Posição %d |Digite um número: t", i);
scanf("%d%*c",&numero[i]);
}
printf("n--------------------------------------------");
printf("nValores armazenados no array");
imprimir();
printf("n--------------------------------------------");
printf("nOrdenando o Array");
troca = 1;
while (troca == 1)
{
troca = 0; for (i = 0; i <= 3; i++)
{
if (numero[i] < numero[i + 1])
{
troca = 1;
aux = numero[i];
numero[i] = numero[i + 1];
numero[i + 1] = aux;
}
}
}
printf("n--------------------------------------------");
printf("nValores ordenados");
imprimir();
printf("n--------------------------------------------");
return 0;
}
void imprimir()
{
printf("n--------------------------------------------");
for (i=0; i<5; i++)
{
printf("n|Posicao: %d | Número: %d|", i, numero[i]);
}
}

16. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 16 de 18
2. VETOR ORDENADO
2.1 VETOR DECRESCENTE
1.ª Passagem no While:
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[0] <= V[1]
200 <= 30
F
i = 1; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[1] <= V[2]
30 <= 10
F
i = 2; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[2] <= V[3]
10 <= 5
V
i = 3; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1

17. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 17 de 18
Verifica Troca = 0
V[i] <= V[i+1]
V[3] <= V[4]
5 <= 0
F
i = 4; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
200 30 10 5 0
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[4] >= V[5]
0 >= ?
F
Não há valores que devem ser trocados entre as posições. Portanto, o while será
executado uma única vez, e o IF que está dentro do FOR nunca será executado.
2.1 VETOR CRESCENTE
1.ª Passagem no While:
i = 0; troca = 1;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[0] >= V[1]
0 >= 5
F
i = 1; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1

18. Prof.ª M.ª Elaine Cecília Gatto (Cissa) Algoritmos de Ordenação: Bublble Sort
(2017) Página 18 de 18
Verifica Troca = 0
V[i] >= V[i+1]
V[1] >= V[2]
5 >= 10
F
i = 2; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[2] <= V[3]
10 <= 30
V
i = 3; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] <= V[i+1]
V[3] <= V[4]
30 <= 200
F
i = 4; troca = 0;
Estado do vetor e posições a serem comparadas:
0 1 2 3 4
0 5 10 30 200
i i+1 i+1 i+1 i+1
Verifica Troca = 0
V[i] >= V[i+1]
V[4] >= V[5]
200 >= ?
F
Não há valores que devem ser trocados entre as posições. Portanto, o while será
executado uma única vez, e o IF que está dentro do FOR nunca será executado.