1 / 54

Classificação Ordenação de Dados

Classificação Ordenação de Dados. Marco Antonio Montebello Júnior marco.antonio@aes.edu.br. Ordenação e Pesquisa de Dados. Ordenação dos dados. Facilitar e aumentar a eficiência das operações de pesquisa sobre esses dados Pode ser crescente ou decrescente

harper-johnston
Download Presentation

Classificação Ordenação de Dados

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. ClassificaçãoOrdenação de Dados Marco Antonio Montebello Júnior marco.antonio@aes.edu.br Ordenação e Pesquisa de Dados

  2. Ordenação dos dados • Facilitar e aumentar a eficiência das operações de pesquisa sobre esses dados • Pode ser crescente ou decrescente • A seqüência de entrada, normalmente, é um vetor com n elementos • Outras possibilidades de estruturas de dados como por exemplo, uma lista encadeada

  3. Ainda mais... • Na prática os números a serem ordenados, raramente, são valores isolados • Normalmente, cada número é componente de um conjunto de dados denominado registro • E o conjunto de registros forma uma tabela • Cada registro contém uma chave, que é o valor a ser ordenado, e demais valores que sempre acompanham a chave • Numa operação de ordenação, sempre que for preciso trocar a posição de uma chave, será necessário alterar a posição de todos os elementos do registro • Na prática, quando os registros possuem uma grande quantidade de dados (além da chave), a ordenação é realizada sobre um vetor (ou lista) de ponteiros para os registros, com o objetivo de minimizar as operações de movimentação de dados

  4. Tabela não ordenada Tabela ordenada ExemplosContigüidade Física • As entradas são fisicamente rearranjadas (todos os elementos de um registro são ordenados fisicamente)

  5. ExemploVetor Indireto de Ordenação • As entradas são mantidas nas posições originais. A seqüência é dada por um vetor gerado durante o processo de classificação (não envolve movimentação dos registros em uma tabela). • Tabela desordenada • Vetor de ordenação

  6. ExemploEncadeamento • As entradas são mantidas nas posições originais. • É formada uma lista encadeada com a ordenação. Utiliza-se um campo a mais na tabela para armazenamento da lista, e não mais o vetor adicional (vetor indireto de ordenação). É preciso utilizar um ponteiro para o primeiro elemento 4 Ponteiro para o primeiro elemento da tabela (reg. 4 contém chave 1)

  7. Ordenação Interna versusOrdenação Externa • A ordenação interna é utilizada num conjunto de dados pequeno • Neste caso a ordenação pode ser realizada inteiramente (ou quase inteiramente) na memória principal • A ordenação externa é utilizada num conjunto de dados grandes • A conseqüência é que a ordenação não pode ser realizada na memória principal • Nesse caso a ordenação é realizada sobre dados armazenados na memória secundária (disco, fita, etc.)

  8. Principais métodos de ordenação interna • Ordenação por Inserção • Inserção Direta • Incrementos Decrescentes (Shell Sort) • Ordenação por Troca • Método da Bolha (Bubble Sort) • Método da Troca e Partição (Quicksort) • Ordenação por Seleção • Seleção Direta • Seleção em Árvore (Heapsort)

  9. Ordenação por Inserção • Nesse método os elementos são inseridos em sua posição correta, em relação aos elementos já classificados • Duas possibilidades : • Inserção Direta • Método Shell

  10. Inserção Direta • É o método mais simples • Utilizado para um conjunto pequeno de dados • Possui baixa eficiência • Nesse método o vetor a ser ordenado é dividido em dois segmentos: • O primeiro segmento contém os elementos já ordenados; • O segundo segmento contém os elementos a serem ordenados

  11. Algoritmo – Inserção Direta • Primeiro elemento está no vetor ordenado e os demais no vetor desordenado; • Retirar o primeiro elemento do vetor desordenado e colocá-lo no vetor ordenado, na sua posição correta; • Repetir o processo para todos os elementos do vetor desordenado.

  12. Algoritmo – Inserção Direta Const TAM = 10 Tipos v = vetor[1..TAM] de inteiros +-------------------------+ Var | Exemplo: | vet: v | | i, j, k, temp: inteiro | 5 | 2 3 4 8 7 | achei: lógico | 2 5 | 3 4 8 7 | | 2 3 5 | 4 8 7 | Início | 2 3 4 5 | 8 7 | Para i = 1 até TAM Faça | 2 3 4 5 8 | 7 | leia (vet[i]) | 2 3 4 5 7 8 || Fim-Para +-------------------------+ Para i = 2 até TAM Faça j = 1 achei = FALSO Enquanto (j < i) E (NÃO achei) Faça /* Compara o */ Se vet[i] < vet[j] Então /* vet[i] com */ achei = VERDADEIRO /* os que estão */ Senão /* à sua */ j = j + 1 /* esquerda */ Fim-Se Fim-Enquanto Se achei Então temp = vet[i] k = i - 1 Enquanto k >= j Faça /* Desloca o */ vet[k+1] = vet[k] /* vetor para */ k = k – 1 /* a direita */ Fim-Enquanto vet[j] = temp Fim-Se Fim-Para Fim.

  13. Algoritmo – Outra versão Const TAM = 10 Tipos v = vetor[1..TAM] de inteiros Var vet: v i, j, k, temp: inteiro achei: lógico Início Para i = 1 até TAM Faça leia (vet[i]) Fim-Para Para j = 2 até TAM Faça chave = vet[j] i = j - 1 Enquanto (i > 0) E (vet[i] > chave) Faça vet[i + 1] = vet[i] i = i - 1 Fim-Enquanto vet[i+1] = chave Fim-Para Fim.

  14. Incrementos Decrescentes (Shell Sort) • Proposto por Ronald L. Shell (1959) • É uma extensão do algoritmo de inserção direta • A diferença com relação à inserção direta é o número de segmentos do vetor • Na inserção direta é considerado um único segmento do vetor onde os elementos são inseridos ordenadamente • No método do Shell são considerados diversos segmentos

  15. Descrição do Método Shell Sort • A ordenação é realizada em diversos passos. A cada passo está associado um incremento I, o qual determina os elementos que pertencem a cada um dos segmentos: • segmento 1 - vet[1], vet[1 + I], vet[1 + 2I], ... • segmento 2 - vet[2], vet[2 + I], vet[2 + 2I], ... ... • segmento k - vet[k], vet[k + I], vet[k + 2I], ...

  16. Descrição do Método Shell Sort • A cada passo todos os elementos (segmentos) são ordenados isoladamente por inserção direta. • No final de cada passo o processo é repetido para um novo incremento I igual a metade do anterior, até que seja executado um passo com incremento I = 1. • O valor do incremento I é sempre uma potência inteira de 2. O valor do incremento inicial é dado por 2**NP, onde NP é o número de passos para ordenar o vetor (fornecido pelo usuário, NP é uma aproximação inicial). • Assim, para NP = 3 o valor do incremento em cada passo seria: • I = 2 ** 3 = 8 (23) • I = 2 ** 2 = 4 (22) • I = 2 ** 1 = 2 (21) • I = 2 ** 0 = 1 (20)

  17. Exemplo: NP = 2 • Vetor original (Desordenado) • Primeiro passo: I = 2 ** NP = 4 (22) • Aplicando inserção direta em cada segmento • Obtém-se o vetor

  18. Exemplo: NP = 2 • Segundo passo: I = I DIV 2 = 2 (I/2)ou NP = NP - 1, I = 2 ** NP = 2 (21) Segmento 1 Segmento 2 • Aplicando inserção direta em cada segmento: • Obtém-se o vetor

  19. Exemplo: NP = 2 • Terceiro passo: I = I DIV 2 = 1ou: NP = NP - 1, I = 2 ** NP = 1 (20) • Nesse último passo os elementos estão próximos das suas posições finais, o que leva a um menor número de trocas. • Aplicando inserção direta ao vetor obtido no passo anterior obtém-se o vetor ordenado:

  20. Algoritmo do Método Shell Const TAM = 12 Tipos v = vetor[1..TAM] de inteiros Var vet: v np, i, j, inc : inteiro Início Para i = 1 até TAM Faça Leia (vet[i]) Fim-Para Leia (np) Para i = np até 0 Passo -1 Faça inc = 2 ** i //2i Para j = 1 até inc Faça Método_Shell (vet, inc, j, TAM) Fim-Para Fim-Para Fim.

  21. Algoritmo do Método Shell Procedimento Método_Shell (Ref vet, r, s, n) Início Var i, j, k, temp: inteiro achei: lógico Para i = (s + r) até n passo r Faça j = s achei = FALSO Enquanto (j < i) E (NÃO achei) Faça Se vet[i] < vet[j] Então achei = VERDADEIRO Senão j = j + r Fim-Se Fim-Enquanto Se achei Então temp = vet[i] k = i + r Enquanto k > (j - r) Faça vet[k + r] = vet[k] k = k - r Fim-Enquanto vet[j] = temp Fim-Se Fim-Para Fim-Método_Shell

  22. Ordenação por Troca • Durante o caminhamento no vetor, se dois elementos são encontrados fora de ordem, suas posições são trocadas • São realizadas comparações sucessivas de pares de elementos • A estratégia de escolha dos pares de elementos estabelece a diferença entre os dois métodos de ordenação por troca. • Dois métodos principais: • Método da Bolha (Bubble Sort) • Método da Partição (Quick Sort)

  23. Método da Bolha (Bubble Sort) • É um método bastante simples, porém lento • O nome bolha se deve ao fato de que os valores flutuam até a sua correta posição como bolhas • O algoritmo é o seguinte: • A cada passo, cada elemento é comparado com o próximo. Se o elemento estiver fora de ordem, a troca é realizada; • Realizam-se tantos passos quantos necessários até que não ocorram mais trocas. • Obs.: Logo no primeiro passo o maior valor vai para o fim

  24. Exemplo do Mecanismo do Método Bolha 500 85 515 60 910 170 890 275 650 430 Passo 1: 85 500 60 515 170 910 890 910 275 910 650 910 430 910 85 500 60 515 170 890 275 650 430 910 Passo 2: 85 60 500 170 515 275 650 430 890 910 Passo 3: 60 85 170 500 275 515 430 650 890 910 Passo 4: 60 85 170 275 500 430 515 650 890 910 Passo 5: 60 85 170 275 430 500 515 650 890 910 Passo 6: nenhuma troca

  25. Algoritmo do Método Bolha /*Nesse algoritmo, a cada passo, a variável k contém a última posição trocada. Após esta, todas já estão classificadas.*/ Const TAM = 20 Tipos v = vetor[1..TAM] de inteiros Var vet: v i, temp, lim, k: inteiro troca: lógico Início Para i = 1 até TAM Faça Leia (vet[i]) Fim-Para troca = VERDADEIRO lim = TAM - 1 Enquanto troca Faça troca = FALSO Para i = 1 até lim Faça Se vet[i] > vet[i + 1] Então temp = vet[i] vet[i] = vet[i + 1] vet[i + 1] = temp k = i troca = VERDADEIRO Fim-Se Fim-para lim = k Fim-Enquanto Fim.

  26. Método da Troca e Partição (Quick Sort) • É o mais rápido entre os métodos apresentados até o momento • E também o mais utilizado • Foi proposto por C. A. R. Hoare em 1962 • Parte do princípio que é mais rápido classificar dois vetores com n/2 elementos cada um, do que um com n elementos (dividir um problema maior em dois menores)

  27. Descrição do Método Quick Sort • A parte mais delicada do método é o particionamento do vetor • O vetor é particionado em três segmentos: • V[1], ..., V[i - 1] V[i] V[i + 1], ..., V[n] • (segmento 1) (segmento 2) (segmento 3) • A partição é realizada através da escolha arbitrária de um elemento (V[i]) de modo que os elementos no segmento 1 sejam menores, e os elementos no segmento 3 sejam maiores do que o elemento escolhido V[i]

  28. Descrição do Método Quick Sort • Após a ordenação dos segmentos 1 e 3, tem-se o vetor original classificado. O processo de partição pode ser repetido para os segmentos 1 e 3 • Obs.: Quando um segmento apresenta um número de elementos menor ou igual a M (um número pré-estabelecido), aplica-se um método simples de ordenação

  29. Algoritmo do Quick Sort • Escolher arbitrariamente um elemento do vetor (normalmente o meio) e colocá-lo em uma variável auxiliar X; • Inicializar dois ponteiros I e J (I = 1 e J = n); • Percorrer o vetor a partir da esquerda até que se encontre um V[I] >= X (incrementando o valor de I); • Percorrer o vetor a partir da direita até que se encontre um V[J] <= X (decrementando o valor de J); • Trocar os elementos V[I] e V[J] (estão fora de lugar) e fazer: I = I + 1 e J = J - 1; • Continuar esse processo até que I e J se cruzem em algum ponto do vetor; • Após obtidos os dois segmentos do vetor através do processo de partição, cada um é ordenado recursivamente

  30. Quicksort – Exemplo (1)

  31. Quicksort – Exemplo (2)

  32. Quicksort – Exemplo (3)

  33. Quicksort – Exemplo (4)

  34. Quicksort – Exemplo (5)

  35. Quicksort – Exemplo (6)

  36. Quicksort – Animação

  37. Algoritmo em pseudocódigo Procedimento QuickSort (esq, dir: inteiro) Início Var x, i, j, aux: inteiro i = esq j = dir x = v[(i + j) DIV 2] Repita //Faça Enquanto x > v[i] Faça i = i + 1 Fim-Enquanto Enquanto x < v[i] Faça j = j - 1 Fim-Enquanto Se i <= j Então aux = v[i] v[i] = v[j] v[j] = aux i = i + 1 j = j - 1 Fim-Se Até Que i > j //Enquanto i < j Se esq < j Então QuickSort (esq, j) Fim-Se Se dir > i Então QuickSort (i, dir) Fim-Se Fim.

  38. Ordenação por Seleção • É realizada uma seleção sucessiva do menor (ou maior) valor contido no vetor • A cada passo este menor (maior) valor é colocado na sua posição correta • Repete-se o processo para o segmento que contém os elementos não selecionados • Duas possibilidades: • Seleção direta • Seleção em árvore

  39. Seleção Direta • A cada passo encontra-se o menor elemento dentro do segmento com os elementos não selecionados; • Troca-se este elemento com o primeiro elemento do segmento; • Atualiza-se o tamanho do segmento (menos um elemento); • Este processo é repetido até que o segmento fique com apenas um elemento

  40. Exemplo 19 25 10 18 35 17 15 13 TAM = 8 10 25 19 18 35 17 15 13 TAM = 7 10 13 19 18 35 17 15 25 TAM = 6 10 13 15 18 35 17 19 25 TAM = 5 10 13 15 17 35 18 19 25 TAM = 4 10 13 15 17 18 35 19 25 TAM = 3 10 13 15 17 18 19 35 25 TAM = 2 10 13 15 17 18 19 25 35 TAM = 1

  41. Algoritmo da Seleção Direta Const TAM = 15 Tipos v = vetor[1..TAM] de inteiros Var vet: v i, j, temp, pos_menor: inteiro Início Para i = 1 até TAM Faça Leia (vet[i]) Fim-Para Para i = 1 até TAM - 1 Faça pos_menor = i Para j = i + 1 até TAM Faça Se vet[j] < vet[pos_menor] Então pos_menor = j Fim-Se Fim-Para temp = vet[i] vet[i] = vet[pos_menor] vet[pos_menor] = temp Fim-Para Fim.

  42. Seleção em Árvore (Heap Sort) • Utiliza uma estrutura de árvore binária para a ordenação • A ordenação é realizada em duas fases

  43. Seleção em Árvore (Heap Sort)Fase 1 • Monta-se uma árvore binária (heap) contendo todos os elementos do vetor de forma que o valor contido em qualquer nodo seja maior do que os valores de seus sucessores. A árvore binária é estruturada no próprio vetor da seguinte forma: • sucessor à esquerda de i: 2i + 1 (se 2i + 1 < n) • sucessor à direita de i: 2i + 2 (se 2i + 2 < n) • Transformação da árvore numheap: é realizada do menor nível até a raiz, trocando-se cada nodo com o maior de seus sucessores imediatos. Repete-se este processo até cada nodo ser maior que seus sucessores imediatos

  44. Seleção em Árvore (Heap Sort)Fase 2 • Após a formação do heap segue-se a fase de classificação propriamente dita, na qual o valor que está na raiz da árvore (maior valor contido na árvore) é colocado na sua posição correta, trocando-o com o elemento de maior índice da árvore (a árvore fica com 1 elemento a menos). • Este novo elemento colocado na raiz pode violar a propriedade do heap, de modo que deve-se restaurar o heap novamente. Este procedimento é repetido até que a árvore fique com um único elemento.

  45. 98 98 98 98 80 66 10 98 66 10 66 66 11 32 24 44 Exemplos de Heaps

  46. 98 66 12 98 66 10 11 24 44 78 Exemplos de Não Heaps

  47. Heap – Exemplo (1) Heap: Entrada:

  48. Heap – Exemplo (2)

  49. Heap – Exemplo (3)

  50. Heap – Exemplo (4)

More Related