Métodos de Pesquisa e Ordenação Estruturas de Dados Melissa Marchiani Palone Zanatta

Algoritmos de pesquisa Pesquisar dados envolve: - determinar se um valor está presente nos dados; Se estiver: - encontrar a localização do valor. OBS: geralmente o valor é denominado de chave de pesquisa

Busca exaustiva O algoritmo testa cada elemento Quando alcança o fim do array - informa ao usuário que a chave não está presente OBS: O array está desordenado

Algoritmo buscaExaustiva int buscaExaustiva (int elem) { int i=0; while (vetor[i]<>elem&&i<tl) i=i+1; if (i < tl && vetor[i] == elem) return i; // achou na posição i else return -1; // não achou }

Busca sequencial O array está ordenado A busca deve testar até o primeiro elemento maior que a chave procurada Se encontrar um elemento maior que a chave procurada, é por que o elemento igual a chave não está lá

Algoritmo buscaSequencial int buscaSequencial(int elem) { int i=0; while (elem > vetor[i]&&i<tl) i=i+1; if (i<tl && elem == vetor[i]) return i; // achou na posição i else return -1; // não achou }

Busca binária A primeira iteração testa o elemento do meio do array Se o elemento do meio = chave pesquisa, o algoritmo termina Se a chave pesquisa < elemento do meio: - a chave de pesquisa não poderá localizar nenhum elemento na segunda metade do array e o algoritmo continua apenas na primeira metade

Busca binária Se a chave pesquisa > o elemento do meio - o algoritmo continua apenas com a segunda metade do array Repare que a cada iteração, metade do array é descartado, ficando apenas a metade que interessa E assim sucessivamente até localizar o elemento ou reduzindo o subarray ao tamanho zero.

Algoritmo buscaBinaria int buscaBinaria(int elem) {int inicio, meio, fim; inicio=0; fim=tl-1; meio=(inicio+fim)/2; while(elem!=vetor[meio]&&inicio<fim) { if(elem>vetor[meio]) inicio=meio+1; else fim=meio; meio=(inicio+fim)/2; } if (elem>vetor[meio]) return(meio+1); else return(meio); }

Algoritmos de classificação Classificar dados, isto é, colocar os dados em ordem crescente ou decrescente, é uma das aplicações mais importantes da computação A escolha do algoritmo só afeta o tempo de execução e o uso de memória do programa

Algoritmos de classificação Os algoritmos da bolha, da seleção e da inserção (direta e binária) são simples de programar, porém são ineficientes O método mais eficiente de classificação é realizado através de permuta entre os elementos (quicksort).

Algoritmo da bolha A técnica chamada de ordenação por submersão (sinking sort) funciona da seguinte forma: - os valores maiores submergem para o final do array - outra técnica é fazer os valores menores subirem gradualmente, até o topo do array (isto é, em direção ao topo do array)

Algoritmo da bolha - A ordenação pela submersão faz várias passagens pelo array - Cada passagem compara sucessivos pares de elementos - Se um par está em ordem crescente, os valores permanecem na mesma ordem - Se um par está em ordem decrescente, é realizada a troca entre os elementos do par

Bubble Sort Algoritmo Bolha; inicio houveTroca = verdade; enquanto houveTroca faça houveTroca = falso para i de 1 até n-1 faça se V[i] > V[i + 1] então inicio troque V[i] e V[i + 1] de lugar houveTroca = verdade fim Fim.

Algoritmo da seleção A primeira iteração do algoritmo seleciona o menor elemento e o permuta pelo primeiro elemento A segunda iteração seleciona o segundo menor item (que é o menor item dos elementos restantes) e o permuta pelo segundo elemento E assim sucessivamente até o penúltimo elemento

Algoritmo da inserção A primeira iteração seleciona o segundo elemento do array Se for menor que o primeiro elemento, o permuta pelo primeiro elemento (ou seja, ordena apenas os dois primeiros elementos do array) A segunda iteração, examina o terceiro elemento e o insere na posição correta com relação aos dois primeiros elementos de modo que todos os três elementos estejam em ordem

Algoritmo da inserção E assim sucessivamente para os demais elementos A inserção pode ser direta e binária A diferença entre elas é que ao procurar o local ideal para inserir o novo elemento entre os elementos já ordenados, pode-se optar por uma busca sequencial ou pela busca binária

QuickSort Se baseia no paradigma de divisão e conquista escolha um pivô (por ex o elemento do meio do array) “arrume” o array de tal forma que: ◦ANTES do pivô devem ficar os elementos menores que o pivô; ◦APÓS o pivô, deverão ficar apenas os elementos maiores que o pivô;

QuickSort ◦esta “arrumação” implica, algumas vezes, na mudança de posição do pivô dentro do array (nem sempre). Ao final desta etapa, o pivô estará na sua posição ideal dentro do array. aplique a mesma lógica aos dois subarrays (da esquerda e da direita), o que implica um processo recursivo.

procedimento QuickSort(X[], IniVet, FimVet) var i, j, pivo, aux início i <- IniVet j <- FimVet pivo <- X[(IniVet + FimVet) div 2] enquanto(i < j) | enquanto (X[i] < pivo) faça | | i <- i + 1 | fimEnquanto | enquanto (X[j] > pivo) faça | | j <- j - 1 | fimEnquanto | se (i <= j) então | | aux <- X[i] | | X[i] <- X[j] | | X[j] <- aux | | i <- i + 1 | | j <- j - 1 | fimSe fimEnquanto se (j > IniVet) então | QuickSort(X, IniVet, j) fimSe se (i < FimVet) então | QuickSort(X, i, FimVet) fimse fimprocedimento