Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
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.
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;
}
}
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
Valores
Posio
Valores
Posio
Valores
11
11
11
55
33
22
22
22
33
44
44
44
33
55
55
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.