5 anos atrás

Elaine Cecília Gatto

Algoritmos de Ordenação: Bubble Sort

ÍNDICE DE CONTEÚDO

Este post faz parte da série Estruturas de Dados. Leia também os outros posts da série:

Sobre o 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.

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.

Ordenando de forma crescente – Ordenação Bubble Sort

1.ª Passagem no While

i = 0; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[0] >= V[1]

200 >= 10

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:

200

i = 1; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[1] >= V[2]

200 >= 0

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:

200

i = 2; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[2] >= V[3]

200 >= 5

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:

200

i = 3; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[3] >= V[4]

200 >= 30

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:

200

i = 4; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[4] >= V[5]

200 >= ?

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:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[0] >= V[1]

10 >= 00

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:

200

i = 1; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[1] >= V[2]

10 >= 5

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:

200

i = 2; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[2] >= V[3]

10 >= 30

i = 3; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[3] >= V[4]

30 >= 200

i = 4; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] >= V[i+1]

V[4] >= V[5]

200 >= ?

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 quando 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:

200

Verifica

Troca = 0

V[i] >= V[i+1]

V[0] >= V[1]

0 >= 5

i = 1; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] >= V[i+1]

V[1] >= V[2]

5 >= 10

i = 2; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] >= V[i+1]

V[2] >= V[3]

10 >= 30

i = 3; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] >= V[i+1]

V[3] >= V[4]

30 >= 200

i = 4; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] >= V[i+1]

V[4] >= V[5]

200 >= ? F

O algoritmo terminou de executar, troca é igual a 0, portanto o vetor está ordenado.

Código fonte para ordenação bubble sort crescente

#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 Array\n");
    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]);
    }
}

#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 Array\n");

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]);

}

Ordenando de forma decrescente – Ordenação Bubble Sort

1.ª Passagem no While

i = 0; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[0] <= V[1]

200 <= 10

i = 1; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[1] <= V[2]

10 <= 0

i = 2; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[2] <= V[3]

0 <= 5

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:

200

i = 3; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[3] <= V[4]

0 <= 30

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:

200

i = 4; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[4] <= V[5]

30 <= ?

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:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[0] <= V[1]

200 <= 10

i = 1; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[1] <= V[2]

10 <= 5

i = 2; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[2] <= V[3]

5 <= 30

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:

200

i = 3; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[3] <= V[4]

5 <= 0

i = 4; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[4] <= V[5]

0 <= ?

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:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[0] <= V[1]

200 <= 10

i = 1; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[1] <= V[2]

10 <= 30

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:

200

i = 2; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[2] <= V[3]

10 <= 5

i = 3; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[3] <= V[4]

5 <= 0

i = 4; troca = 1;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 1

V[i] <= V[i+1]

V[4] <= V[5]

0 <= ?

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á dada quando 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:

200

Verifica

Troca = 0

V[i] <= V[i+1]

V[0] <= V[1]

200 <= 30

i = 1; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] <= V[i+1]

V[1] <= V[2]

30 <= 10

i = 2; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] <= V[i+1]

V[2] <= V[3]

10 <= 5

i = 3; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] <= V[i+1]

V[3] <= V[4]

5 <= 0

i = 4; troca = 0;

Estado do vetor e posições a serem comparadas:

200

Verifica

Troca = 0

V[i] <= V[i+1]

V[4] <= V[5]

0 <= ?

O algoritmo terminou sua execução, troca é igual a zero, o vetor está ordenado.

Código fonte para ordenação bubble sort decrescente

#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 Array\n");
    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]);
    }
}

#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 Array\n");

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]);

}

Vetor ordenado

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.

Finalizando

No próximo artigo falarei sobre Selection Sort. Fiquem atentos! Até.

Outros artigos da série

<< Struct – Registros em Linguagem CVetor de Struct >>

JUNTE-SE HOJE À COMUNIDADE EMBARCADOS

Fazer Parte

Elaine Cecília Gatto

72 posts

No momento (2021) sou uma mera Estudante de Doutorado em Ciência da Computação na UFSCar, e tenho trabalhado com Classificação Multirrótulo (Aprendizado de Máquina - Inteligência Artificial). No entanto, trabalho como Professora de Informática (Profissionalizante) desde os anos 2000, e como Professora Universitária de Computação desde 2011. Além disso, eu também sou Geek, Nerd, Otaku, Gamer, Escritora de artigos técnicos e científicos, Palestrante, Cantora e Jogadora de vôlei (tento pelo menos!). De vez em quando gosto de desenhar e pintar pra desestressar. Gosto de cerveja de trigo e vinho seco (aceito presentes ok!). Sou fã de Michael Jackson, da franquia Rocky Balboa, e também amo os animes/mangás Haikyuu e Macross. Sou uma pessoa comum que quer compartilhar conhecimento e agregar valor à vida das pessoas. Obrigada por ler até aqui! A gente se vê =)

Esta obra está licenciada com uma Licença Creative Commons Atribuição-CompartilhaIgual 4.0 Internacional.

Software

Iniciante

Home » Software » Algoritmos de Ordenação: Bubble Sort

Comentários:

Notificações

8 Comentários

recentes

antigos mais votados

Inline Feedbacks

View all comments

Jailson Souza Carvalho

16/01/2020 00:36

Olá elaine, parabéns pelo excelente artigo, me ajudou muito, muito obg de coração msm, estou ingressando agora na área, faço Bacharelado em Ciência da Computação, e pretendo um dia ser uma pessoa tão incrível como vc, lhe desejo muito sucesso na sua vida profissional e pessoal.

Responder

Elaine Cecília Gatto

Autor

Reply to Jailson Souza Carvalho

07/01/2021 08:40

Oi Jailson, obrigada pelo seu comentário e desculpe pela demora pra responder. Ando bem ocupada com o doutorado. Fico muito feliz mesmo que tenha lhe ajudado! Você já é incrível também, lembre-se disso!!! [ ]s

Responder

Caio Alexandre

10/04/2018 00:53

Ola, meu nome e Caio e sou iniciante em C, teria como me explicar o porque de usar no scanf(“%d%*c”,&numero[i]); o “%d%*c”? Eu nao entendi muito bem essa expressão

Responder

Elaine Cecília Gatto

Autor

Reply to Caio Alexandre

22/06/2018 13:14

Então Caio, eu uso o CODEBLOCKS para fazer a implementação dos códigos. Por algum motivo, se eu não coloco isso no CODEBLOCKS, o código não funciona corretamente, acredito que seja um problema da IDE. Se você usar outra IDE é bem provável que não precisará utilizar o %*c, que neste contexto força a leitura dos caracteres do teclado, é como um FFLUSH que normalmente se usa na IDE Dev C. Tudo bem? [ ]s

Responder

Nanos Klark

23/08/2017 00:12

Você poderia postar mais sobre estes algoritimos de ordenação, manipulação e etc? (tanto para vetores, matrizes ou gerais)
Por exemplo, metodos para achar valores em vetores gigantes (GB de informaçoes) de forma mais rapida…

Responder

Elaine Cecília Gatto

Reply to Nanos Klark

23/08/2017 09:06

Oi!!! Obrigada por comentar e valeu pela dica. Gostaria de entender qual é a sua necessidade em relação a métodos para encontrar valores em muita informação. Normalmente, bancos de dados fornecem essas capacidades. Poderia explicitar melhor? Agradeço

Responder

José

Reply to Elaine Cecília Gatto

24/08/2017 12:58

Apenas curiosidade mesmo para quando precisar, ja ter o conhecimento. É sempre legal ter alguns algoritimos otimizados para certas atividades… Você poderia trazer alguns destes algoritimos, eu não conheço nome de algoritimos entao não posso indicar um 🙁

Responder

Elaine Cecília Gatto

Reply to José

18/09/2017 20:44

Entendi!!!!! Vou tentar ok! É que normalmente, em se tratando de grandes conjuntos de dados, usa-se técnicas de mineração de dados, que já é algo bem mais complexo/complicado que estes algoritmos de ordenação. Blz?!

Responder

Talvez você goste:

Cookie	Duração	Descrição
cf_ob_info	past	The cf_ob_info cookie is set by Cloudflare to provide information on HTTP Status Code returned by the origin web server, the Ray ID of the original failed request and the data center serving the traffic.
cf_use_ob	past	Cloudflare sets this cookie to improve page load times and to disallow any security restrictions based on the visitor's IP address.
cookielawinfo-checkbox-advertisement	1 year	Set by the GDPR Cookie Consent plugin, this cookie is used to record the user consent for the cookies in the "Advertisement" category .
cookielawinfo-checkbox-analytics	1 year	Set by the GDPR Cookie Consent plugin, this cookie is used to record the user consent for the cookies in the "Analytics" category .
cookielawinfo-checkbox-functional	1 year	The cookie is set by the GDPR Cookie Consent plugin to record the user consent for the cookies in the category "Functional".
cookielawinfo-checkbox-necessary	1 year	Set by the GDPR Cookie Consent plugin, this cookie is used to record the user consent for the cookies in the "Necessary" category .
cookielawinfo-checkbox-others	1 year	Set by the GDPR Cookie Consent plugin, this cookie is used to store the user consent for cookies in the category "Others".
cookielawinfo-checkbox-performance	1 year	Set by the GDPR Cookie Consent plugin, this cookie is used to store the user consent for cookies in the category "Performance".

Cookie	Duração	Descrição
bcookie	2 years	LinkedIn sets this cookie from LinkedIn share buttons and ad tags to recognize browser ID.
bscookie	2 years	LinkedIn sets this cookie to store performed actions on the website.
lang	session	LinkedIn sets this cookie to remember a user's language setting.
lidc	1 day	LinkedIn sets the lidc cookie to facilitate data center selection.
UserMatchHistory	1 month	LinkedIn sets this cookie for LinkedIn Ads ID syncing.

Cookie	Duração	Descrição
__gads	1 year 24 days	The __gads cookie, set by Google, is stored under DoubleClick domain and tracks the number of times users see an advert, measures the success of the campaign and calculates its revenue. This cookie can only be read from the domain they are set on and will not track any data while browsing through other sites.
_ga	2 years	The _ga cookie, installed by Google Analytics, calculates visitor, session and campaign data and also keeps track of site usage for the site's analytics report. The cookie stores information anonymously and assigns a randomly generated number to recognize unique visitors.
_ga_LKV4ZRRMWD	2 years	This cookie is installed by Google Analytics.
_gid	1 day	Installed by Google Analytics, _gid cookie stores information on how visitors use a website, while also creating an analytics report of the website's performance. Some of the data that are collected include the number of visitors, their source, and the pages they visit anonymously.
CONSENT	2 years	YouTube sets this cookie via embedded youtube-videos and registers anonymous statistical data.

Cookie	Duração	Descrição
_fbp	3 months	This cookie is set by Facebook to display advertisements when either on Facebook or on a digital platform powered by Facebook advertising, after visiting the website.
ANONCHK	10 minutes	The ANONCHK cookie, set by Bing, is used to store a user's session ID and also verify the clicks from ads on the Bing search engine. The cookie helps in reporting and personalization as well.
fr	3 months	Facebook sets this cookie to show relevant advertisements to users by tracking user behaviour across the web, on sites that have Facebook pixel or Facebook social plugin.
IDE	1 year 24 days	Google DoubleClick IDE cookies are used to store information about how the user uses the website to present them with relevant ads and according to the user profile.
MUID	1 year 24 days	Bing sets this cookie to recognize unique web browsers visiting Microsoft sites. This cookie is used for advertising, site analytics, and other operations.
NID	6 months	NID cookie, set by Google, is used for advertising purposes; to limit the number of times the user sees an ad, to mute unwanted ads, and to measure the effectiveness of ads.
test_cookie	15 minutes	The test_cookie is set by doubleclick.net and is used to determine if the user's browser supports cookies.
VISITOR_INFO1_LIVE	5 months 27 days	A cookie set by YouTube to measure bandwidth that determines whether the user gets the new or old player interface.
YSC	session	YSC cookie is set by Youtube and is used to track the views of embedded videos on Youtube pages.
yt-remote-connected-devices	never	YouTube sets this cookie to store the video preferences of the user using embedded YouTube video.
yt-remote-device-id	never	YouTube sets this cookie to store the video preferences of the user using embedded YouTube video.
yt.innertube::nextId	never	This cookie, set by YouTube, registers a unique ID to store data on what videos from YouTube the user has seen.
yt.innertube::requests	never	This cookie, set by YouTube, registers a unique ID to store data on what videos from YouTube the user has seen.

Cookie	Duração	Descrição
__wpdm_client	session	No description
_clck	1 year	No description
_clsk	1 day	No description
_dc_gtm_UA-43275330-1	1 minute	No description
AnalyticsSyncHistory	1 month	No description
CLID	1 year	No description
li_gc	2 years	No description
SM	session	No description available.

Algoritmos de Ordenação: Bubble Sort

Sobre o Bubble Sort

Vetor desordenado

Ordenando de forma crescente – Ordenação Bubble Sort

Código fonte para ordenação bubble sort crescente

Ordenando de forma decrescente – Ordenação Bubble Sort

Código fonte para ordenação bubble sort decrescente

Vetor ordenado

Finalizando

Outros artigos da série

JUNTE-SE HOJE À COMUNIDADE EMBARCADOS

ESP8266 com Arduino

Arduino – Comunicação Serial

Estação meteorológica com Arduino

SÉRIES

ULWOS – Multitarefa no RL78

Controlador VGA

Monitoramento de água com IoT

Trazendo o mundo real para dentro do processador

Sistemas Operacionais de Tempo Real

A arte de especificar e encontrar componentes

Projetos de desenvolvimento: Antes de começar

Boas práticas para o desenvolvimento de software

GNU ARM Cross-toolchain

Shape The World