Professional Documents
Culture Documents
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:
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
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
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.
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
ou varivel que armazena se houve troca ou no na passagem. Se uma passagem chega ao seu final sem troca a ordenao cessa.
[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.
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
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); }
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!