Introduo s Estruturas de Dados/Algoritmos de Ordenao

< Introduo s Estruturas de Dados Ir para: navegao, pesquisa

Ordenao o ato de se colocar os elementos de uma sequncia de informaes, ou dados, em uma relao de ordem predefinida. O termo tcnico em ingls para ordenao sorting, cuja traduo literal "classificao". Dado uma seqencia de n dados:

O problema de ordenao uma permutao dessa seqencia:

tal que:

para alguma relao de ordem. Algumas ordens so facilmente definidas. Por exemplo, a ordem numrica, ou a ordem alfabtica --crescentes ou decrescentes. Contudo, existem ordens, especialmente de dados compostos, que podem ser no triviais de se estabelecer. Um algoritmo que ordena uma conjunto, geralmente representada num vetor, chamado de algoritmo de ordenao. Algoritmo de ordenao em cincia da computao um algoritmo que coloca os elementos de uma dada sequncia em uma certa ordem -- em outras palavras, efetua sua ordenao completa ou parcial. As ordens mais usadas so a numrica e a lexicogrfica.Existem vrias razes para se ordenar uma sequncia. Uma delas a possibilidade se acessar seus dados de modo mais eficiente. Entre os mais importantes, podemos citar bubble sort (ou ordenao por flutuao), heap sort (ou ordenao por heap), insertion sort (ou ordenao por insero), merge sort (ou ordenao por mistura) e o quicksort. Existem diversos outros, que o aluno pode com dedicao pesquisar por si. Para estudo no entanto nos concentraremos nos principais : Selection Sort, Bubble Sort e Quicksort.

ndice
[esconder]

1 Natureza dos Dados 2 Selection Sort (Ordenao por Seleo) o 2.1 Teste de Mesa de Selection Sort

o o

2.2 Algoritmo do Selection Sort

3 Bubble Sort (Ordenao Bolha) o 3.1 Teste de Mesa 3.2 Algoritmo Bubble Sort 4 Quicksort (Ordenao Rpida) 5 Resumo 6 Ligaes externas

[editar] Natureza dos Dados

Para melhor escolha de um mtodo de ordenao preciso saber sobre a natureza dos dados que sero processados. Entre elas destacam-se duas: Tempo de acesso a um elemento e a possibilidade de acesso direto a um elemento. O tempo de acesso a um elemento a complexidade necessria para acessar um elemento em uma estrutura;
1 Ex: Uma estante de livros com seu ttulos bem visveis.

A possibilidade de acesso direto a capacidade ou impossibilidade de acessar um elemento diretamente na estrutura.

1 Ex: Uma pilha de livros dentro de uma caixa, onde precisamos tirar um a um para saber qual a sua natureza.

Para classificarmos estes dois ambientes de atuao, costumamos utilizar o meio em que est armazenado os dados. Em termos computacionais utiliza-se a designao Ordenao Interna, quando queremos ordenar informaes em memria. E Ordenao Externa, quando queremos ordenar informaes em arquivo.

[editar] Selection Sort (Ordenao por Seleo)

O Selection Sort utiliza um o conceito de "selecionar o elemento mais apto". Ele seleciona o menor ou maior valor do vetor p.ex. e passa para a primeira (ou ltima posio dependendo da ordem requerida), depois o segundo menor para a segunda posio e assim sucessivamente com (n-1) elementos restantes at os dois ltimos.

[editar] Teste de Mesa de Selection Sort

Vetor inicial:
4 3 1 2

Primeira passagem: Posio 0- compara 4 com 3.Como 3 menor que 4 este fixado como mnimo, compara 3 com 1. Como este menor do que 3 fixado como

mnimo.Compara 1 com 2. Como continua sendo menor, fixado. Ao chegar ao final do vetor, como 1 o menor elemento em comparao com o 4, eles trocam de posio.
1 3 4 2

Segunda Passagem: Posio 1- como j temos 1 como o menor elemento do vetor, passamos para a posio 1. Comparamos 3 com 4.Como menor, 3 continua como mnimo.Compara com 2. Como 2 menor este fixado como mnimo.Ao chegar ao final do vetor, como 2 o menor elemento em comparao com o 3, eles trocam de posio.
1 2 4 3

Terceira Passagem: Posio 2- pegamos o elemento da posio 2 (4) e comparamos com o 3. Como 3 o ltimo elemento do vetor e menor do que 4 , trocamos as posies.Como os dois elementos so os ltimos do vetor, o Selection Sort encerra-se.
1 2 3 4

[editar] Algoritmo do Selection Sort

O algoritmo normalmente implementado por duas repeties iterando sobre a estrutura em questo. Um exemplo de algoritmo : para i=0 at n-1 mnimo=i para j=i+1 at N
se vetor[j]<vetor[mnimo] mnimo=j

auxiliar=vetor[i] vetor[i]=vetor[mnimo] vetor[mnimo]=auxiliar

[editar] Bubble Sort (Ordenao Bolha)

O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de ordenao dos mais simples. A idia comparar dois elementos e troc-los de posio, at que os elementos de maior valor sejam levados para o final do vetor. O processo continua at a ordenao total do vetor lembrando a forma como as bolhas em um tanque de gua procuram seu prprio nvel, e disso vem o nome do algoritmo. A complexidade desse algoritmo de ordem quadrtica (O(n)). Por isso, ele no recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados. Tambm necessria uma condio de parada, geralmente uma flag

ou varivel que armazena se houve troca ou no na passagem. Se uma passagem chega ao seu final sem troca a ordenao cessa.

[editar] Teste de Mesa

Vetor inicial:
4 2 5 1

Primeira Passagem: compara 4 com 2. 4 maior que 2.Mudam de posio.

2 4 5 1

Segunda Passagem: compara 4 com 5. 4 menor que 5.Permanece.

2 4 5 1

Terceira passagem: compara 5 com 1. 1 menor que 5.Mudam de posio.

2 4 1 5

Quarta passagem: compara 2 com 4. 2 menor que 4.Permanece.

2 4 1 5

Quinta passagem: compara 4 com 1. 1 menor que 4.Mudam de posio.

2 1 4 5

Sexta passagem: compara 4 com 5. 4 menor que 5.Permanece.

2 1 4 5

Stima passagem: compara 2 com 1. 1 menor que 2.Trocam de posio.

1 2 4 5

Oitava passagem: compara 2 com 4. 2 menor do que 4.Permanece.

1 2 4 5

Nona passagem: compara 4 com 5. 4 menor do que 5. Permanece.

1 2 4 5

Dcima passagem: no h mudanas. Sai do lao.

1 2 4 5

[editar] Algoritmo Bubble Sort

O algoritmo pode ser descrito em pseudo-cdigo como segue abaixo. V um VETOR de elementos que podem ser comparados e n o tamanho desse vetor. BUBBLESORT (V[], n) 1 houveTroca <- verdade # uma varivel de controle 2 enquanto houveTroca for verdade faa 3 houveTroca <- falso 4 para i de 1 at n-1 faa 5 se V[i] vem depois de V[i + 1] 6 ento troque V[i] e V[i + 1] de lugar e 7 houveTroca <- verdade

[editar] Quicksort (Ordenao Rpida)

O quicksort (Ordenao Rpida) um mtodo de ordenao baseado no conceito de dividir-e-conquistar. Inicialmente ele seleciona um elemento o qual chamado de piv, depois remove este piv e particiona os elementos restantes em duas sequncias, uma com os valores menores do que o piv e outras com valores maiores.

[editar] Resumo

Algoritmo de ordenao uma implementao em uma linguagem de programao para ordenar um conjunto de dados. Existem diversos tipos de algoritmos de ordenao. Os principais so Selection Sort, Bubble Sort e Quicksort.

MTODOS DE ORDENAO E PESQUISA Aprenda a ordenar e pesquisar listas - aplicvel a microcontroladores

Quem trabalha com microcontroladores sabe que muitas vezes necessrio utilizar matrizes, tabelas, pequenos arquivos e as vezes tambm pequenos banco de dados, tudo inserido em sua memria (no formato lista). E em alguns casos, necessrio ordenar para posterior pesquisa. Este artigo descrever alguns mtodos de ordenao e pesquisa considerados bsicos, mas que podero ser aplicados com qualquer microcontrolador presente no mercado atualmente.

MTODOS DE ORDENAO Quando trabalhamos com listas, existem ocasies em que necessitamos ordena-las para facilitar as pesquisas. Podemos ordenar os valores de uma matriz (ou banco de dados) do mais baixo para o mais alto (ordem crescente) ou ainda mais alto para o

mais baixo (ordem crescente). Sem esse tipo de ordenao toda e qualquer pesquisa em uma matriz seria muito difcil e demorada. Basicamente o que teria de se fazer posicionar o ponteiro no topo da matriz e ir comparando cada um dos elementos da matriz com o valor procurado. Para uma matriz pequena, esse "mtodo" no assim algo to complexo e talvez seja o mais utilizado. Mas para matrizes um pouco maior, esse mtodo consome muito tempo de processamento, tempo este que muitas vezes o sistema no dispes. Nestes casos o melhor ordenar a matriz para somente ento comear as pesquisas. Voc deve estar neste momento pensado: Mas a ordenao tambm no consome um tempo de processamento?. A resposta para este pensamento SIM. Mas voc deve considerar que este processamento ser realizado apenas uma nica vez, durante a inicializao do sistema e/ou quando muitos novos elementos forem acrescentados. E creia, o tempo de processamento realizado numa ordenao muito menor que o tempo de duas pesquisas feitas em uma base de dados desordenada. Sendo assim, vale a pena ordenar! Existem alguns mtodos (algoritmos) muito utilizados para ordenar matrizes (listas e/ou matrizes). So eles: Bubble Sort (ordenao tipo bolha), Select Sort (ordenao por seleo), Shell Sort (ordenao por diviso e insero) e Quick Sort (ordenao por diviso e conquista). A seguir descreverei os mesmos.

ORDENAO BUBBLE SORT O algoritmo Bubble Sort consome tempo e processamento. Apesar de simples, no deve ser utilizado com matrizes ou listas muito extensas para evitar lentido no processamento. Seu funcionamento muito simples. O Algoritmo faz um loop (lao) pelos valores da matriz comparando-os e movendo o maior para a posio anterior. Este mtodo cria uma ordenao decrescente. Para criar uma ordenao crescente, o algoritmo dever mover o maior valor para a posio posterior, aps o elemento testado. Veja um exemplo abaixo. Modelo Bubble Sort a)ordem decrescente Posio 0 1 2 3 4 Valores 44 33 55 22 11 Posio 0 1 2 3 4 Valores 44 55 33 22 11 Posio 0 1 2 3 4 Valores 55 44 33 22 11

b)ordem crescente Posio 0 1 2 3 4 Valores 44 33 55 22 11 Posio 0 1 2 3 4 Valores 33 44 55 22 11 Posio 0 1 2 3 4 Valores 33 44 22 55 11

Posio 0 1 2

Valores 33 44 22

Posio 0 1 2

Valores 33 22 44

Posio 0 1 2

Valores 33 22 11

3 4

11 55

3 4

11 55

3 4

44 55

Posio 0 1 2 3 4

Valores 33 11 22 44 55

Posio 0 1 2 3 4

Valores 11 33 22 44 55

Posio 0 1 2 3 4

Valores 11 22 33 44 55

Lembrando sempre que a dificuldade de ordenao est relacionada com a disposio dos elementos na matriz (lista) e tambm com o nmero de elementos presentes na mesma. O box abaixo mostra um exemplo de segmento de cdigo, desenvolvido na Linguagem de Programao C, para o modelo Bubble Sort. Exemplo de segmento de cdigo para Bubble Sort //*************************************************************************** // Funo bubble_sorte Recebe uma matriz desordenada e a ordena com // algoritmo bubble sort // // Entradas matriz a ser ordenada e tamanho da matriz a ordenar // Sadas - nenhuma //*************************************************************************** void bubble_sort(unsigned char matriz[], unsigned int tamanho){ unsigned int i, j; unsigned char temp; for (i=0; i < tamanho; i++) for(j=0;j < tamanho; j++) if (matriz[i] < matriz[j]){ temp=matriz[i]; matriz[i]=matriz[j]; matriz[j]=temp; } }

ORDENAO SELECT SORT O algoritmo Select Sort tambm consome processamento e tempo, e assim, tambm no adequado em matrizes e listas muito grandes. Ele trabalha selecionando um elemento como o primeiro da lista, por exemplo. realizada uma pesquisa na lista para encontrar o valor mnimo e este ento posicionado no lugar do elemento pesquisado. A pesquisa continua procurando o segundo elemento menor (maior que o mnimo e menor que o selecionado). Esta ordenao ser crescente. Para obter uma ordenao decrescente, basta operar o algoritmo de maneira contrria. A figura abaixo mostra um exemplo hipottico para este modo de ordenao, no modo crescente, e o box mais abaixo trs um exemplo de segmento de cdigo do modelo Select Sort desenvolvido na Linguagem C. Modelo Select Sort Posio 0 1 2 3 4 Valores 44 33 55 22 11 Posio 0 1 2 3 4 Valores 11 33 55 22 44 Posio 0 1 2 3 4 Valores 11 22 55 33 44

Posio 0 1 2 3 4

Valores 11 22 33 55 44

Posio 0 1 2 3 4

Valores 11 22 33 44 55

Exemplo de segmento de cdigo para Select Sort //*************************************************************************** // Funo select_sorte Recebe uma matriz desordenada e a ordena com // algoritmo select sort // // Entradas matriz a ser ordenada // - tamanho da matriz a ordenar // Sadas - nenhuma //*************************************************************************** void select_sort(unsigned char matriz[], unsigned int tamanho){ unsigned char temp; unsigned int atual, j; for (atual=0; atual < tamanho; atual++) for (j = atual + 1; j < tamanho; j++) if (matriz[atual] > matriz[j]){ temp=matriz[atual]; matriz[atual]=matriz[j]; matriz[j]=temp; } }

ORDENAO SHELL SORT A ordenao Shell Sort compara os elementos de uma matriz que esto separados por uma distncia especfica chamada gap at que os elementos comparados com o gap corrente estejam em ordem. O gap ento dividido por 2 e o processo continua, at que o gap seja igual a 1 e nenhuma diviso possa mais ser feita (com um valor inteiro como resultado). Ao final do processo, a matriz estar ordenada. Este mtodo se parece muito com o algoritmo tipo bolha (Buble Sort) somado ao tipo seleo (Select Sort), com a diferena de ser mais rpido e podermos escolher quais elementos da matriz sero ordenados. Assim, este algoritmo pode ser considerado

um dos que consome menor processamento e tambm tempo de execuo. A figura abaixo demonstra um exemplo do algoritmo. No box mais abaixo vocr encontrar um exemplo de segmento de cdigo para o modelo Shell Sort desenvolvido na Linguagem C. Modelo Shell Sort Posio 0 1 2 3 4 Valores 11 55 22 44 33 Posio 0 1 2 3 4 Valores 11 33 22 44 55 Posio 0 1 2 3 4 Valores 11 22 33 44 55

Exemplo de segmento de cdigo para Shell Sort //*************************************************************************** // Funo shell_sorte Recebe uma matriz desordenada e a ordena com // algoritmo shell sort // // Entradas matriz a ser ordenada e tamanho da matriz a ordenar // Sadas - nenhuma //*************************************************************************** void shell_sort(unsigned char matriz[], unsigned int tamanho){ unsigned int i, gap; unsigned char temp, ret; gap = tamanho / 2; do { do{ ret=0; for (i=0; i< tamanho gap; i++) if (matriz[i] >matriz[i+gap]){ temp=array[i]; array[i]=array[i+gap]; array[i+gap]=temp; ret=1; } } while(ret); } while (gap = gap / 2); }

ORDENAAO QUICK SORT

Este algoritmo seleciona o valor central da lista como um separador. A partir da ele cria duas listas: a primeira com os valores menores que o separador e outra com os valores maiores ou iguais ao separador. A seguir a ordenao chama a si mesma recursivamente, sempre selecionando um novo separador nas listas, e criando novas listas menores at que estas tenham apenas um nico elemento. O algoritmo ento reposiciona os valores das novas listas na lista original. Ao final do algoritmo uma matriz (lista) estar ordenada. A figura abaixo mostra um exemplo deste algoritmo. Modelo Quick Sort

Note que as novas listas so geradas levando em conta a posio da lista anterior. Assim o programa saber exatamente qual a posio de cada valor. O leitor deve observar porm que neste mtodo, o consumo de memria bem grande e isto, para alguns microcontroladores, pode ser um fator limitante. O box 4 mostra um exemplo de segmento de cdigo, desenvolvido na Linguagem C, para a aplicao da Quick Sort. Exemplo de cdigo para Quick Sort //*************************************************************************** // Funo quick_sorte Recebe uma matriz desordenada e a ordena com // algoritmo quick sort // // Entradas matriz a ser ordenada e ndices primeira e ltima posies // Sadas - nenhuma //*************************************************************************** void quick_sort(unsigned char matriz[], unsigned int primeiro, unsigned int ultimo){ unsigned char temp; unsigned int high, low, separador; low = primeiro; high = ultimo; separador = matriz[(primeiro + ultimo) / 2]; do { while(matriz[low] < separador) low++; while(matriz[high] > separador)

high--; if (low <= high){ temp=matriz[low]; matriz[low++] = matriz[high]; matriz[high--] = temp; } } while (low <= high); if (primeiro < high) quick_sort(matriz, primeiro, high); if (low < ultimo) quick_sort(matriz, low, ultimo); }

MTODOS DE PESQUISA Como dito no incio deste artigo ordenar preciso. Se uma base de dados ou matriz est ordenada, nada melhor que aplicar os mtodos corretos de pesquisa a mesma. E os algoritmos para pesquisa so muitos. Porm possvel destacar os dois principais e mais utilizados: Busca/Pesquisa Seqencial e Busca/Pesquisa Binria.

BUSCA SEQUNCIAL O algoritmo Busca Seqencial executa a pesquisa de um elemento em uma matriz comparando-o aos elementos da matriz um aps o outro at obter o resultado verdadeiro ou chegar ao fim da matriz. Este tipo de busca s vivel se a matriz (lista) for pequena (ou mdia) e/ou no estiver ordenada. Devido ao seu modo de operao, a mesma costuma consumir tempo. O box abaixo mostra um exemplo desenvolvido na Linguagem C (hipottico). Segmento de cdigo exemplo para Busca Seqencial //*************************************************************************** // Funo seek_seq Realiza uma busca em uma matriz usando o algoritmo //busca seqencial // // Esta funo requer a criao da matriz em modo global, assim como // a definio do nmero mximo de elementos da mesma (ELEMENTOS_MATRIZ) // // Entradas valor a ser procurado // Sadas - nenhuma //*************************************************************************** void seek_seq(unsigned int busca){ found = FALSE; i = 0; while ((i < ELEMENTOS_MATRIZ) && (!found)){ if (MATRIZ[I] == busca) found = TRUE; else i++; } if (i < ELEMENTOS_MATRIZ) printf(Valor encontrado na matriz %d\n,i); else printf(Valor no encontrado); }

BUSCA BINRIA A busca binria s deve ser executada em matrizes (listas) previamente ordenadas, seja no modo crescente ou decrescente. A pesquisa binria divide por dois a lista analisada e compara o valor. Se o valor central for maior que o objeto da pesquisa, o

algoritmo divide novamente a lista em dois, desta vez considerando apenas a parte central e o topo da lista. Se o valor central for menor, a nova diviso ser feita entre a parte central e o final da lista. Agora o algoritmo compara novamente o objeto da pesquisa com o valor apresentado e continua a diviso at obter o resultado positivo, ou at no ser mais possvel realizar a diviso da matriz. Se isto ocorrer, porque o valor no foi encontrado e o algoritmo devolve este resultado. Note que esta pesquisa muito rpida e a mais adequada para uso com matrizes (listas) muito grandes. O box abaixo mostra um segmento de cdigo que pode ser utilizado como exemplo pelo leitor, para o algoritmo de Busca Binria. Segmento de cdigo exemplo para Busca Binria //*************************************************************************** // Funo seek_bin Realiza uma busca em uma matriz utilizando o algoritmo // busca binria // // Esta funo requer a criao da matriz em modo global, assim como // a definio do nmero mximo de elementos da mesma (ELEMENTOS_MATRIZ) // // Entradas valor a ser procurado // Sadas - nenhuma //*************************************************************************** void seek_bin(unsigned int valor){ found = 0; high = tamanho_da_lista; low = 0; middle = (high + low) / 2; while ((!found) && (high >= low)){ if (valor == MATRIZ[middle]) found = 1; else if (value < MATRIZ[middle]) high = middle 1; else low = middle + 1; mid = (high + low) /2; } } Obs: todos os exemplos passados foram preparados na Linguagem C e podem ser facilmente adaptados para outras linguagens de programao como BASIC, PASCAL e mesmo ASM, apenas baseando-se nos conceitos envolvidos. Um outro detalhe importante que o segmento exemplo para Quick Sort utiliza a recursividade (uma funo pode chamar a s mesma, n vezes), muito comum para os programadores C. Porm este recurso no permitido em alguns compiladores C para microcontroladores. Antes de utilizar o segmento demonstrado, certifique-se que seu compilador aceita recursividade.

CONCLUSO

Apesar de alguns compiladores oferecerem em suas bibliotecas poderosos recursos para ordenao e pesquisa em listas e outros, acredito que conhecer os mtodos utilizados para tal seja importante para a formao do bom profissional. Assim quando voc se deparar com um compilador que no possui tais recursos, poder cri-los a partir do que foi explicado neste artigo, gerando assim suas prprias bibliotecas. Bons estudos com muitas ordenaes e buscas! At a prxima!