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

Valores

Posio

Valores

Posio

Valores

44

44

55

33

55

44

55

33

33

22

22

22

11

11

11

b)ordem crescente
Posio

Valores

Posio

Valores

Posio

Valores

44

33

33

33

44

44

55

55

22

22

22

55

11

11

11

Posio

Valores

Posio

Valores

Posio

Valores

33

33

33

44

22

22

22

44

11

11

11

44

55

55

55

Posio

Valores

Posio

Valores

Posio

Valores

33

11

11

11

33

22

22

22

33

44

44

44

55

55

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

Valores

Posio

Valores

Posio

Valores

44

11

11

33

33

22

55

55

55

22

22

33

11

44

44

Posio

Valores

Posio

Valores

11

11

22

22

33

33

55

44

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 gapseja
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

Valores

Posio

Valores

Posio

Valores

11

11

11

55

33

22

22

22

33

44

44

44

33

55

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!

Copyright deste contedo reservado para Mrcio Jos Soares e protegido pela Lei de Direitos Autorais
de 19 de Fevereiro de 1998. estritamente proibida a reproduo total ou parcial do contedo desta
outros pontos da internet, livros ou outros tipos de publicaes comerciais ou no, sem a prvia auto
escrito do autor.