Estrutura de Dados (Linguagem C / C++) São Paulo, 2010 Universidade Paulista (UNIP) Estrutura de Dados (Linguagem C / C++) Prof. Msc. Vladimir Camelo Vladimir.professor@gmail.com 24/03/2017 vladimir.professor@gmail.com

Conceitos de Árvores e Árvores Binárias São Paulo, 2010 Universidade Paulista (UNIP) Conceitos de Árvores e Árvores Binárias Prof. Msc. Vladimir Camelo Vladimir.professor@gmail.com 24/03/2017 vladimir.professor@gmail.com

Introdução Uma das mais importantes classes de estruturas de dados em computação são as árvores. Aproveitando-se de sua organização hierárquica, muitas aplicações são realizadas usando-se algoritmos relativamente simples, recursivos e de eficiência bastante razoável. 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas Uma árvore é uma estrutura de dados que se caracteriza por uma relação de hierarquia entre os elementos que a compõem. Exemplos de estruturas em forma de árvores são: O organograma de uma empresa; A divisão de um livro em capítulos, seções, tópicos, etc; A árvore genealógica de uma pessoa. 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas De um modo um pouco mais formal, podemos dizer que uma árvore é um conjunto finito de um ou mais nodos (nós ou vértices), tais que: existe um nodo denominado raiz; os demais nodos formam m>= 0 conjuntos disjuntos s1, s2, ... , sm, tais que cada um desses conjuntos também é uma árvore (denominada sub-árvore). 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas Uma floresta é um conjunto de árvores. Se v é um nodo de A, a notação Av indica a subárvore de v com raiz A. Para visualizar esse conceito, pode-se representa-lo graficamente. Há formas diferentes de representações gráficas de uma árvore. Em todas elas, cada nodo poderá ser associado a um identificador, denominado rótulo. 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas a) Representação hierárquica b) Representação por conjuntos (diagrama de inclusão) 24/03/2017 vladimir.professor@gmail.com

( A ( B ( D ( ) E ( ) ) ) ( C ( F ( ) ) ) ) Definições e representações básicas c) Representação por expressão parentetizada (parênteses aninhados) Cada conjunto de parênteses correspondentes contém um nodo e seus filhos. Se um nodo não tem filhos, ele é seguido por um par de parênteses sem conteúdo. ( A ( B ( D ( ) E ( ) ) ) ( C ( F ( ) ) ) ) d) Representação por expressão não parentetizada Cada nó é seguido por um número que indica a quantidade de filhos desse nodo, e em seguida por esses filhos, representados do mesmo modo. A 2 B 2 D 0 E 0 C 1 F 0 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas Pode-se representar uma árvore de muitos outros modos, mas é interessante notar que, dentre os exemplos apresentados, a representação a) é a que permite uma melhor visualização da estrutura. As representações c) e d) não permitem boa visualização da estrutura, mas podem ser úteis para guardar em arquivos os dados de uma árvore. Como, por definição, os subconjuntos s1, s2,...,sm são disjuntos, cada nó só pode ter um pai. Assim, o desenho a seguir, por exemplo, não representa uma árvore: 24/03/2017 vladimir.professor@gmail.com

Definições e representações básicas 24/03/2017 vladimir.professor@gmail.com

Definições Dada uma árvore qualquer: A linha que liga dois nodos da árvore denomina-se aresta. Diz-se que existe caminho entre dois nodos V e W da árvore, se a partir do nodo V puder-se chegar ao nodo W percorrendo-se as arestas que ligam os nodos intermediários entre V e W. Observa-se que existe sempre um caminho entre a raiz e qualquer nodo da árvore. 24/03/2017 vladimir.professor@gmail.com

Definições Dada uma árvore qualquer: Se houver um caminho entre V e W, começando em V diz-se que V é um nodo ancestral de W e W é um nodo descendente de V. Se este caminho contiver uma única aresta, diz-se que V é o nodo pai de W e que W é um nodo filho de V. Dois nodos que são nodos filhos do mesmo nodo pai são denominados nodos irmãos. 24/03/2017 vladimir.professor@gmail.com

Definições Dada uma árvore qualquer: Uma característica inerente a árvores é que qualquer nodo, exceto a raiz, tem um único nodo pai. Se um nodo não possui nodos descendentes, ele é chamado de folha ou nodo terminal da árvore. Grau de um nodo é o número de nodos filhos do mesmo. Obviamente que um nodo folha tem grau zero. 24/03/2017 vladimir.professor@gmail.com

Definições Dada uma árvore qualquer: O Nível de um nodo é o número de nodos existentes no caminho entre a raiz e o próprio nodo. A raiz tem nível 1. O grau da árvore é igual ao grau do nodo de maior grau da árvore. O nível da árvore é igual ao nível do nodo de maior nível da árvore. 24/03/2017 vladimir.professor@gmail.com

Definições 24/03/2017 vladimir.professor@gmail.com

Altura e Profundidade 24/03/2017 vladimir.professor@gmail.com

Nível e Profundidade 24/03/2017 vladimir.professor@gmail.com

Exercício 24/03/2017 vladimir.professor@gmail.com

Exercício Responda: Qual é a raiz da árvore? Quais são os nodos terminais? Qual o grau da árvore? Qual o nível da árvore? Quais são os nodos descendentes do nodo D? Quais são os nodos ancestrais do nodo #? Os nodos 4 e 5 são nodos irmãos? 24/03/2017 vladimir.professor@gmail.com

Exercício Responda: Há caminho entre os nodos C e S? Qual o nível do nodo 5? Qual o grau do nodo A? 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore objetivo principal: visitar os nós da árvore percurso prefixo: um nó é visitado antes dos seus descendentes ex. de aplicação: impressão de um documento estruturado por capítulos e parágrafos percurso sufixo: um nó é visitado depois dos seus descendentes ex. de aplicação: determinação do espaço ocupado por um diretório num sistema de arquivos de um computador percurso por nível: os nós de determinado nível são visitados antes dos nós do nível seguinte 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore Um percurso em extensão é visitar cada nó começando do menor nível e move-se para os níveis mais altos nível após nível, visitando cada nó da esquerda para a direita. Sua implementação é directa quando uma fila é utilizada. Depois que um nó é visitado, seus filhos, se houver algum, são colocados no final da fila e o nó no início da fila é visitado. Assim, os nós do nível n+1 serão visitados somente depois de ter visitados todos os nós do nível n. 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore Breadth - First Search (BFS) Fila: 13 13 10 25 Fila: 2, 12, 20, 31 Fila: 12, 20, 31 2 12 20 31 Fila: 20, 31 Fila: 31 29 Fila: 29 Percurso: 13, 10, 25, 2, 12, 20, 31, 29 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore void BreadthFirst() { Queue q; Node *p = root; if (p != 0) { q.enqueue(p); while (!q.empty()){ p = q.dequeue(); visit(p); if (p->left != 0) q.enqueue(p->left); if (p->right != 0) q.enqueue(p->right); } 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore O percurso em profundidade prossegue tanto quanto possível à esquerda (ou direita), então se move para trás até a primeira encruzilhada, vai um passo para a direita (ou esquerda) e novamente, tanto quanto possível, para a esquerda (ou direita). Repete-se este processo até que todos os nós sejam visitados. 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore Depth - First Search (DFS) V – Visitar um nó L – Percorrer à esquerda R – Percorrer à direita VLR VRL LVR RVL LRV RLV 13 10 25 2 12 20 31 29 24/03/2017 vladimir.professor@gmail.com

Árvores binárias Conforme já mencionado, as árvores constituem as estruturas não seqüenciais com maior aplicação em computação. Dentre as árvores, as binárias são, sem dúvida, as mais comuns. Deve-se observar que a ordem em que estão posicionadas as sub-árvores em relação à raiz é fundamental. 24/03/2017 vladimir.professor@gmail.com

Árvores binárias Uma vez que cada nodo tem no máximo dois nodos filhos, cada um destes nodos (se houverem) são identificados segundo a sua posição relativa à raiz. Distingue-se, então, o nodo filho à esquerda do nodo filho à direita e, conseqüentemente, a sub-árvore à esquerda da sub-árvore à direita. 24/03/2017 vladimir.professor@gmail.com

Árvores binárias - Aplicações Expressões aritméticas. Processo de decisão. Busca. A B C F D E H I 24/03/2017 vladimir.professor@gmail.com

Árvores de expressões aritméticas Árvore binária associada com uma expressão aritmética Nós internos: operadores Nós externos: operandos Exemplo: árvore da expressão aritmética para a expressão (2  (a - 1) + (3  b)) +  - 2 a 1 3 b 24/03/2017 vladimir.professor@gmail.com

Árvores de decisão Refeição rápida? Que tal um café? Pode ser caro? Árvore binária associada com um processo de decisão Nós internos: questões com respostas sim/não Nós externos: decisões Exemplo: Onde jantar Refeição rápida? Que tal um café? Pode ser caro? Cantina Shopping Abade Tábua de carne Sim Não 24/03/2017 vladimir.professor@gmail.com

Árvores binárias - Exemplo Nos exemplos anteriores, as árvores apresentadas são distintas, pois no primeiro exemplo, o nodo A tem somente um filho à esquerda e no segundo exemplo, o nodo tem um filho a direita. Transformação em árvore binária A raiz da árvore (sub-árvore) será a raiz da árvore (sub-árvore) binária. 24/03/2017 vladimir.professor@gmail.com

Árvores binárias - Exemplo O nodo filho mais à esquerda da raiz da árvore (sub-árvore) será o nodo filho à esquerda da raiz da árvore (sub-árvore) binária. Cada nodo irmão de V, da esquerda para a direita, será o nodo filho à direita do nodo irmão da esquerda, até que todos os nodos filhos da raiz da árvore (sub-árvore) já tenham sido incluídos na árvore binária em construção. 24/03/2017 vladimir.professor@gmail.com

Representações de árvores binárias (implementações) Cada nodo componente de uma árvore binária tem no máximo dois filhos, sendo necessários, portanto, dois campos de elos para representa-lo. A configuração de um nodo numa árvore binária é a que segue: Sendo que EloE (i) indica o endereço do nodo filho à esquerda do nodo de índice i e EloD (i) aponta para o nodo filho à direita. 24/03/2017 vladimir.professor@gmail.com

Representações de árvores binárias (implementações) Uma árvore binária pode, então, ser representada por; uma matriz Info que conterá os campos de informações dos nodos, e dois vetores de ligação, EloE e EloD. ou uma estrutura com um campo info, um campo EloE e um EloD. Sendo conhecido o índice do nodo raiz de uma árvore, a mesma é completamente definida (o índice da raiz esteja contido na variável RAIZ). 24/03/2017 vladimir.professor@gmail.com

Representações de árvores binárias (implementações) Exemplo: a seguinte árvore (os números abaixo de cada nodo indicam o índice do mesmo) 24/03/2017 vladimir.professor@gmail.com

Representações de árvores binárias (implementações) Pode ser representado por: 24/03/2017 vladimir.professor@gmail.com

Caminhos e, árvores binárias Há diversas formas de manipulação de árvores binárias e, em geral, estas supõem o exame dos conteúdos (informações) dos nodos. O acesso sistemático aos nodos de uma árvore de maneira que cada nodo seja examinado no máximo uma única vez (para que não haja repetição), sugere que a árvore seja percorrida segundo algum critério pré-estabelecido. Esta ação de percorrer a árvore, com a condição de que cada nodo seja examinado no máximo uma vez, denomina-se caminhamento na árvore binária. 24/03/2017 vladimir.professor@gmail.com

Caminhos e, árvores binárias Se for realizado um caminhamento numa árvore de forma que todos os seus nodos sejam visitados (acessados), os mesmos são implicitamente organizados segundo uma ordem linear. Dependendo do critério estabelecido para caminhar na árvore, obtém-se uma seqüência dos nodos correspondentes xi1 xi2 ... xin, em que: 24/03/2017 vladimir.professor@gmail.com

Caminhos e, árvores binárias n é o número de nodos da árvore; xj é o conteúdo do nodo que ocorre na j-ésima posição na seqüência de caminhamento da árvore; e xik ocorre antes de xip na seqüência se o nodo com informação xik é visitado antes do que o nodo xip, segundo o caminhamento escolhido. 24/03/2017 vladimir.professor@gmail.com

Caminhos e, árvores binárias Em geral são utilizadas três formas de caminhamentos em árvores binárias e estas são determinadas dependendo da ordem em que são visitados o nodo raiz, sua sub-árvore à esquerda e sua subárvore à direita (o termo “visitar” significa a realização de alguma operação sobre a informação do nodo, como modificação da mesma, impressão ou qualquer outra). Os três caminhamentos usuais são descritos como segue: Caminhamento PRÉ_FIXADO (raiz-esquerda-direita) a) visitar a raiz; b) caminhar na sub-árvore à esquerda, segundo este caminhamento; c) caminhar na sub-árvore à direita, segundo este caminhamento. 24/03/2017 vladimir.professor@gmail.com

Caminhos e, árvores binárias Caminhamento INFIXADO (esquerda-raiz-direita) a) caminhar na sub-árvore à esquerda, segundo este caminhamento; b) visitar a raiz; c) caminhar na sub-árvore à direita, segundo este caminhamento. Caminhamento PÓS-FIXADO (esquerda-direita-raiz) a) caminhar na sub-árvore à esquerda, segundo este caminhamento b) caminhar na sub-árvore à direita, segundo este caminhamento c) visitar a raiz; 24/03/2017 vladimir.professor@gmail.com

Percurso em árvore void inorder(Node *p) { if (p != 0) { inorder(p->left); visit(p); inorder(p->right); } void preorder(Node *p) { preorder(p->left); preorder(p->right); void postorder(Node *p) { if (p != 0) { postorder(p->left); postorder(p->right); visit(p); } 24/03/2017 vladimir.professor@gmail.com

Deterioração quando inserimos utilizando a inserção simples, dependendo da distribuição de dados, pode haver deterioração. Árvores deterioradas perdem a característica de eficiência de busca. 24/03/2017 vladimir.professor@gmail.com

Propriedades Ab (BT) Notação Propriedades: n número de nós e = i + 1 e número de nós externos i número de nós internos h altura (height) Propriedades: e = i + 1 n = 2e - 1 h  i h  (n - 1)/2 e  2h h  log2 e h  log2 (n + 1) - 1 24/03/2017 vladimir.professor@gmail.com

Propriedades Ab (BT) Nível Nós 1 2 3 4 8 1 2 3 4 8 Número máximo de nós em um nível h é 2h Número total de nós é, no máximo é 2h+1 -1 24/03/2017 vladimir.professor@gmail.com

Tipo Abstrato de Dado (TAD) Árvores binária O TAD Árvore Binária possui os métodos de árvore. Métodos adicionais: No getFilhoEsquerdo() No getFilhoDireito() boolean éFilhoEsquerdo() boolean éFilhoDireito() Métodos de atualização podem ser definidos por estruturas de dados que implementam o TAD ArvoreBinaria 24/03/2017 vladimir.professor@gmail.com

Estrutura de dados para AB Um nó é um objeto que armazena Elemento Nó pai Filho da esquerda Filho da direita Objetos nós implementam o TAD Position  B A D C E B D A C E 24/03/2017 vladimir.professor@gmail.com

Podemos usar um array Estrutura de dados para AB c d e f g h i j k l m n o 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 a b c d e f g h i j k l m n o 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 24/03/2017 vladimir.professor@gmail.com

Representação em C É possível definir um tipo para representar uma árvore binária. A informação a ser armazenada são valores de caracteres simples. Inicialmente será discutido como é possível representar uma estrutura de árvore binária em C. Que estrutura pode-se utilizar para representar um nó da árvore? Cada nó deve armazenar três informações: a informação propriamente dita, no caso um caractere, e dois ponteiros para as sub-árvores, à esquerda e à direita. 24/03/2017 vladimir.professor@gmail.com

Representação em C Da mesma forma que uma lista encadeada é representada por um ponteiro para o primeiro nó, a estrutura da árvore como um todo é representada por um ponteiro para o nó raiz. 24/03/2017 vladimir.professor@gmail.com

Criando árvores 24/03/2017 vladimir.professor@gmail.com

Árvore Vazia 24/03/2017 vladimir.professor@gmail.com

Exemplo 24/03/2017 vladimir.professor@gmail.com

Exemplo 24/03/2017 vladimir.professor@gmail.com

Como isso pode ser feito? Exemplo Alternativamente, a árvore poderia ser criada recursivamente com uma única atribuição, seguindo a sua estrutura. Como isso pode ser feito? 24/03/2017 vladimir.professor@gmail.com

Exemplo 24/03/2017 vladimir.professor@gmail.com

Exibindo conteúdo da árvores Como é chamada essa forma de exibição? E para exibir na forma in-fixada? E na pós-fixada? 24/03/2017 vladimir.professor@gmail.com

Liberando memória 24/03/2017 vladimir.professor@gmail.com

Criação e Liberação 24/03/2017 vladimir.professor@gmail.com

Criação e Liberação 24/03/2017 vladimir.professor@gmail.com

Buscando um elemento 24/03/2017 vladimir.professor@gmail.com

Buscando um elemento 24/03/2017 vladimir.professor@gmail.com

Conceitos de Árvores e Árvores Binárias São Paulo, 2010 Universidade Paulista (UNIP) Conceitos de Árvores e Árvores Binárias Prof. Msc. Vladimir Camelo Vladimir.professor@gmail.com 24/03/2017 vladimir.professor@gmail.com

24/03/2017 vladimir.professor@gmail.com

24/03/2017 vladimir.professor@gmail.com

24/03/2017 vladimir.professor@gmail.com

24/03/2017 vladimir.professor@gmail.com

24/03/2017 vladimir.professor@gmail.com

Algoritmos de Ordenação São Paulo, 2010 Universidade Paulista (UNIP) Algoritmos de Ordenação Prof. MSc. Vladimir Camelo Vladimir.professor@gmail.com 24/03/2017 vladimir.professor@gmail.com

Quicksort eficiente naturalmente recursivo - implementação seria “complicada” sem recursão Algoritmo Básico "dividir para conquistar" particiona a lista de elementos em duas partes e as classifica independentemente a posição exata da partição depende da lista Vamos estudar agora um algoritmo de sort inventado em 1960 por C.A.R.Hoare, e tem sido muito estudaddo desde então. Quicksort é popular por ser um bom algoritmo de sort (funciona bem em uma grande variedade de situações), fácil de implementar e consome menos recurso do que qq outro método de sort. Quicksort é feito no próprio local, usa apenas uma memória auxiliar pequena, uma pilha, requer em torno de N logN operações para em média classificar N itens e tem um loop interno muito pequeno usa N2 no pior caso - é sensível, um pequeno erro de implementação pode causar grandes estragos em arquivos o desempenho desse algoritmo é bem conhecido por extenso estudo matemático e po experiências que comprovam, e está em uma grande variedade de aplicações versões do quicksort foram desenvolvidas para melhorar performance - vamos estudar essas variações 24/03/2017 vladimir.professor@gmail.com

Quicksort: algoritmo básico quicksort (int e, int d) { int i; if (d >e){ i = partition (e,d); /* importante * / quicksort(e,i-1); quicksort(i+1,d); } 24/03/2017 vladimir.professor@gmail.com

Quicksort: algoritmo básico A primeira chamada: quicksort(1,N) A função partition deve: rearrumar a lista de acordo com as três condições: o elemento a[i] está em seu lugar final na lista todos os elementos em a[e] a a[i-1] são menores que a[i] todos os elementos em a[i+1] a a[d] são maiores ou iguais a a[i] 24/03/2017 vladimir.professor@gmail.com

Quicksort: algoritmo básico Partition: escolha arbitrariamente um elemento pivot a[r] – elemento que estará na sua posição ao final percorra a lista da esquerda até que um elemento maior que a[r] seja encontrado percorra a lista da direita até um elemento menor que a[r] esses dois elementos estão fora de posição  troque-os 24/03/2017 vladimir.professor@gmail.com

Quicksort: algoritmo básico parar a varredura toda vez que um elemento for igual ao pivot a[r] Continuando dessa forma garante-se que todos os elementos da lista esquerda são menores e os a direita são maiores 24/03/2017 vladimir.professor@gmail.com

Quicksort: algoritmo básico Quando os ponteiros de varredura se cruzam, o processo está quase completo falta trocar a[r] com o elemento mais a esquerda da sub-lista da direita – o elemento a[i] a posição i foi definida aplicar quicksort nas sublistas de e a i-1 e i+1 a d i é o elemento que já está na sua posição 24/03/2017 vladimir.professor@gmail.com

Quicksort: Partition 9 6 3 5 2 7 2 6 3 5 9 7 2 6 3 5 7 9 j i i j 1a iteração (do-while externo) j i 2 6 3 5 9 7 2a iteração (do-while externo) i j 2 6 3 5 7 9 fora do-while externo - trocas 7 - em sua posição definitiva partition retorna i = 4 24/03/2017 vladimir.professor@gmail.com

Quicksort: Partition a[j] = a[i]; } partition(int e, int d) {int v, i, j; v = a[d]; i = e -1; j = d; do { do{ i = i+1; /* esquerda*/ } while (a[i] < v) && (i< d) ; do{ j = j-1; /* direita*/ } while (a[j] > v) && (j > 0); t=a[i]; a[i]=a[j]; a[j]=t; } while (j > i) /* para desfazer a troca extra realizada quando j<= i e saiu do while interno (t já tem o valor de a[i]) */ a[j] = a[i]; a[i] = a[r]; a[r] = t; return (i); } 24/03/2017 vladimir.professor@gmail.com

Quicksort É difícil imaginar um loop interno mais simples simplesmente incrementam um ponteiro e fazem uma comparação é o que faz o quicksort ser realmente rápido pode-se garantir que a[d] nunca será o maior ou o menor elemento o particionamento da lista seria desequilibrado em relação ao número de elementos 24/03/2017 vladimir.professor@gmail.com

Quicksort: Partition Pegue arbitrariamente 3 elementos de a: a[d], a[e] e a[ (e+d)/2] Compare os 3 elementos e defina o valor médio Troque com a[d] Execute o partition Vantagem: acrescentam-se um número fixo de instruções e não testes que variam com o tamanho da lista 24/03/2017 vladimir.professor@gmail.com

Quicksort: Características o algoritmo não é estável tempo de processamento depende da seleção do pivô quanto ao tratamento do cruzamento dos ponteiros na presença de chaves iguais tanto faz se a varredura de ambos os ponteiros parar, um continuar e outro parar, nenhum parar mudanças devem ser feitas no algoritmo apresentado para listas com grande número de chaves repetidas o maior problema desse algoritmo é que é extremamente ineficiente em arquivo simples Por exemplo, se for chamado com um arq. que já está classificado, as partições serão degeneradas e o pgm vai chamar a si mesmo N vezes, somente fixando um elemento em cada chamada. (sub-arquivo da direita de tam 1) o algoritmo não é estável qdo existem chaves iguais: deve fazer ambos os ponteiros parar em chaves iguais ao elemento sedo particionado, um andar e outro parar, nenhum parar essa questão foi estudada matematicamente em detalhe e chegou-se a conclusão que o melhor é parar os dois ponteiros => isso tende a balancear a partição no caso de chaves iguais outra questão é o tratamento do cruzamento dos ponteiros na presença de chaves iguais. o pgm acima está terminando a varredura qdo j < i e, então usa quicksort (l,j) para o primeiro call recursivo => qdo j = i => pode-se colocar dois elementos na posição se deixar o loop funcionar mais uma vez se não fizer isso, o sub-arquivo da direita vai ter sua chave mais a direita a menor, pode fazer o arq. degenerar Mudanças devem ser feitas no algoritmo apresentado para arq. com grande número de chaves repetidas 24/03/2017 vladimir.professor@gmail.com

MergeSort Seja uma lista A de n elementos. O algoritmo consiste das seguintes fases Dividir A em 2 sub-listas de tamanho  n/2 Conquistar: ordenar cada sub-lista chamando MergeSort recursivamente Combinar as sub-lista ordenadas formando uma única lista ordenada caso base: lista com um elemento 24/03/2017 vladimir.professor@gmail.com

MergeSort entrada 7 5 2 4 1 6 3 0 7 5 2 4 1 6 3 0 Dividir 7 5 2 4 1 6 3 0 Combinar 2 4 5 7 0 1 3 6 0 1 2 3 4 5 6 7 saída 24/03/2017 vladimir.professor@gmail.com

MergeSort MergeSort ordena as posições e, e+1, ..., d-1, d da lista A MergeSort (e,d) { if (e < d ){ meio = (e+d)/2; MergeSort (e, meio); MergeSort (meio+1, d); Merge (e, meio, d); } 24/03/2017 vladimir.professor@gmail.com

MergeSort while (i < m) do { Merge (e, m, d) { B [k] = A [i]; k++; i++; } while (j < d) do { B [k] = A [j]; k++; j++; for (i = 0; i < d; i++) A [i] = B [i]; Merge (e, m, d) { i = e; j = m+1; k = e; while (i < m) && (j < d) do { if (A [i] < A[j]) { B [k] = A [i]; k++; i++; } else { B [k] = A [j]; k++; j++; } 24/03/2017 vladimir.professor@gmail.com

MergeSort algoritmo de ordenação estável Se dois elementos são iguais eles nunca são trocados de ordem Importante, por exemplo, se os elementos já estão ordenados segundo alguma chave secundária poderiamos eliminar a lista B? a copia final de B para A é necessária? 24/03/2017 vladimir.professor@gmail.com

SelectionSort O Selection Sort é um algoritmo que ordena itens verificando repetidamente os itens restantes para encontrar o menor deles e movê-lo para uma posição final. A idéia por trás do selection sort é que para ordenar N itens você tem que passar por todos eles. No primeiro passo você encontra o maior valor, e então troca ele pelo último item. Assim o maior item está agora na posição N. 24/03/2017 vladimir.professor@gmail.com

SelectionSort No segundo passo você faz uma varredura apenas nos N-1 elementos. O maior dos itens é troca de posição com o item na posição N-1. Assim o maior de todos os itens está agora na última posição; o segundo maior na segunda maior posição. Este processo é repetido, com um item sendo colocado na sua posição correta a cada vez. 24/03/2017 vladimir.professor@gmail.com

SelectionSort Depois de N passos, a coleção inteira de dados está ordenada. Uma variação simples é encontrar o menor item a cada vez e colocá-lo na frente. Para ordenar em ordem decrescente, o maior item é encontrado a cada vez e movido para a frente. 24/03/2017 vladimir.professor@gmail.com

SelectionSort: Algoritmo PROCEDIMENTO SelectionSort(Matriz_de_Inteiro v[]) INICIO PARA( i <== 0 ENQUANTO i<v.comprimento INCREMENTAR i<==i+1) INICIO_PARA inteiro k <== i PARA (inteiro j<==i+1 ENQUANTO j<v.comprimento INCREMENTAR j<==j+1) INICIO_PARA SE(v[j] < v[k]) INICIO_SE k<==j FIM_SE FIM_PARA SWAP(v,k,j) FIM_PARA FIM. 24/03/2017 vladimir.professor@gmail.com

SelectionSort: Algoritmo PROCEDIMENTO swap(Matriz_de_Inteiro v[], Inteiro J, inteiro aposJ) INICIO INTEIRO aux <== 0 aux <== v[j] v[j] <== v[aposJ] v[aposJ] <== aux FIM. 24/03/2017 vladimir.professor@gmail.com

SelectionSort: Teste Teste de mesa com Selection Sort crescente dados as seguintes variáveis: v[0] = 48, v[1] = 23, v[2] = 15, v[3] = 5, v[4] = 3 Dados 48 23 15 5 3 1ª varredura 2ª varredura 3ª varredura 4ª varredura Impressão 24/03/2017 vladimir.professor@gmail.com

SelectionSort: Vantagens e Desvantagens É estável, pois sempre mantém os itens na mesma ordem em que foram inseridos. Simples pela sua facilidade de uso. Desvantagens Não é muito eficiente para listas longas. 24/03/2017 vladimir.professor@gmail.com

RadixSort O Radix Sort é um algoritmo que ordena itens separando-os em grupos que tenham algo em comum para depois juntá-los novamente na ordem correta. A idéia por trás do Radix Sort é de fazer a separação dos itens conforme o dígito com maior valor (dígito à esquerda) ou o menor valor (dígito à direita). Radix Sort sendo implementado no modo de dígito com menor valor (o mais comum): 24/03/2017 vladimir.professor@gmail.com

RadixSort No primeiro passo o algoritmo irá verificar os dígitos do campo da unidade de todos os itens do vetor. Cada item então é , de um modo figurativo, jogado em uma caixa correspondente ao dígito da unidade de cada item. Ou seja 21 e 81 na “caixa 1”, 42 e 12 na “caixa 2” e assim por diante. No segundo passo o algoritmo irá verificar os dígitos do campo da dezena de todos os itens do vetor (que já foram organizados uma vez). 24/03/2017 vladimir.professor@gmail.com

RadixSort Cada item então é novamente jogado em sua caixa correspondente, mas respeitando a ordem estabelecida pela verificação anterior. Quando é encontrado o item com maior número de dígitos, a verificação / ordenação para e então o Radix faz a junção dos dados e apresenta a lista ordenada. Como foi dito o processo pode ser feito inversamente, ou seja, indo do dígito de maior valor para o de menor valor (esquerda p/ direita). 24/03/2017 vladimir.professor@gmail.com

RadixSort: ALgoritmo PROCEDIMENTO radixexchange (esq, dir, b: inteiro; var A: Vetor) var t, i, j: inteiro; INICIO Se (dir > esc) E (b >= 0) ENTÃO INICIO i <== esc; j <== dir; REPITA ENQUANTO (bits(A[i], b, 1) == 0 ) E (i < j) FAÇA i<== i + 1 ENQUANTO (bits(A[j], b, 1) == 0 ) E (i < j) FAÇA j<== j - 1 t <== A[i]; A[i] <== A[j]; A[j] <== t ATÉ QUE j = i Se (bits(A[r], b, 1) = 0 ) ENTÃO j <== j = 1 radixexchange(esc, j - 1, b - 1) radixexchange(j, dir, b - 1) FIM SE FIM 24/03/2017 vladimir.professor@gmail.com

RadixSort: Vantangens e Desvantagens É estável, pois sempre mantém os itens na mesma ordem em que foram inseridos. É mais rápido que alguns algoritmos comparativos. É simples e eficiente. Desvantagens: Não possui flexibilidade de ordenação, só trabalha com a ordem lexicográfica. Se não for modificado, não trabalha bem com float e números negativos. 24/03/2017 vladimir.professor@gmail.com

BubbleSort Bubblesort compara elementos adjacentes e troca estes elementos se não estiverem na ordem correta. Este algoritmo de ordenação requer várias passagens pelos dados. Durante a primeira passagem, comparamos os dois primeiros itens do vetor. Se estiverem na ordem errada, são trocados. Vamos estudar agora um algoritmo de sort inventado em 1960 por C.A.R.Hoare, e tem sido muito estudaddo desde então. Quicksort é popular por ser um bom algoritmo de sort (funciona bem em uma grande variedade de situações), fácil de implementar e consome menos recurso do que qq outro método de sort. Quicksort é feito no próprio local, usa apenas uma memória auxiliar pequena, uma pilha, requer em torno de N logN operações para em média classificar N itens e tem um loop interno muito pequeno usa N2 no pior caso - é sensível, um pequeno erro de implementação pode causar grandes estragos em arquivos o desempenho desse algoritmo é bem conhecido por extenso estudo matemático e po experiências que comprovam, e está em uma grande variedade de aplicações versões do quicksort foram desenvolvidas para melhorar performance - vamos estudar essas variações 24/03/2017 vladimir.professor@gmail.com

BubbleSort Comparam-se então os dois itens do par seguinte - ou seja, a posição 2 e 3 do vetor. Se estiverem desordenados trocam-se. Continuamos a comparar os pares seguintes e a trocar os itens do par sempre que estiverem desordenados, até ao fim do vetor. 24/03/2017 vladimir.professor@gmail.com

BubbleSort Embora o vetor não fique ordenado após a primeira passagem, o maior elemento foi “bubbled” para a sua posição, no fim do vetor. Na segunda passagem, volta para o início do vetor e é considerado os pares de itens como na primeira passagem. No entanto, não é incluído o último, e o maior, elemento. 24/03/2017 vladimir.professor@gmail.com

BubbleSort A segunda passagem só leva em conta N-1 elementos do vetor. Após a segunda passagem teremos o segundo maior elemento na sua posição correta. Agora, ignorando os últimos dois elementos, que já estão na ordem correta, continua com as passagens subseqüentes até que o vetor fique ordenado. 24/03/2017 vladimir.professor@gmail.com

BubbleSort 24/03/2017 vladimir.professor@gmail.com

Insertion Sort Insertion sort parte um vetor em duas regiões: a região ordenada e a não ordenada. Inicialmente, o vetor corresponde à região não ordenada. Em cada passo, pega-se o primeiro elemento da região não ordenada e coloca-o na ordem correta da região ordenada. O primeiro passo é trivial e pode ser omitido. 24/03/2017 vladimir.professor@gmail.com

Insertion Sort O movimento do primeiro elemento da região não ordenada para a região ordenada é ignorado considerando a primeira posição do vetor como a região ordenada, e as restantes posições como a região não ordenada. 24/03/2017 vladimir.professor@gmail.com

Insertion Sort Copia 10 Desloca o 29 Insere o 10; copia 14 Insere o 14 Copia o 13 Desloca o 14, 29, 37 Insere o 13 24/03/2017 vladimir.professor@gmail.com

Heapsort Método que simula uma árvore binária completa, por meio deste método utiliza-se uma simulação de uma arvore binária completa e utiliza-se certas funções especiais deste tipo de dado para realizar a ordenação Uma árvore com estrutura heap é aquela em que, para toda sub-árvore, o nó raiz é um divisor de valores, ou seja, os valores maiores estão sempre de um lado e os menores estão do outro lado. Deste modo o elemento no topo da árvore é sempre o elemento de inicio da seqüência (em modo crescente o menor). 24/03/2017 vladimir.professor@gmail.com

Heapsort - Utilização Este método tem em seu pior caso de inserção de um dado na árvore em razão de log n, o que seria realizado utilizando percorrer o tamanho da árvore, não a árvore inteira. Este é um método bastante eficiente porém requer a construção e ordenação de uma árvore binária, o que o torna mais complexo de ser implementado, e utiliza mais recursos. 24/03/2017 vladimir.professor@gmail.com

Counting Sort Método de ordenação linear. Requer o tamanho máximo de um valor dentro da seqüência para então utilizar uma seqüência virtual de contagem que tem este tamanho máximo, fazendo com que todos os valores da seqüência original sejam contados e que seja colocado na posição referente a seu valor nesta seqüência virtual a quantidade de valores referentes a cada posição. Então utiliza outra seqüência auxiliar com o tamanho da seqüência original que irá conter os valores da seqüência original ordenando-os através da busca nesta seqüência original na quantidade de vezes que contém cada uma das posições da seqüência virtual de contagem. 24/03/2017 vladimir.professor@gmail.com

Counting Sort - Utilização Este método só pode ser utilizado com números inteiros, visto que sua forma de ordenação é através de utilização de uma seqüência posicional que irá receber a quantidade de vezes que o valor referente a tal posição aparece na seqüência. Para garantir estabilidade ele deve varrer os elementos do lado contrário a sua determinada ordenação, ou seja, para ordenação crescente ele deve varrer do último ao primeiro elemento. 24/03/2017 vladimir.professor@gmail.com

Counting Sort - Utilização Este é um método a ser implementado quando a comparação entre os elementos da seqüência é um problema, ele utiliza operações aritméticas e atribuições para realizar seu trabalho. No entanto para uma seqüência em que o valor máximo é muito grande ele utiliza muitos recursos sem necessidade. 24/03/2017 vladimir.professor@gmail.com

Bucket Sort Método de ordenação linear que supõe que os elementos a serem ordenados possuem uma natureza peculiar. Pro exemplo, os elementos devem estar uniformemente distribuídos em um intervalo semi-aberto, a idéia é dividir este intervalo em n segmentos de mesmo tamanho (buckets) e distribuir os n elementos nos seus respectivos segmentos. 24/03/2017 vladimir.professor@gmail.com

Bucket Sort Como os elementos estão distribuídos uniformemente, espera-se que o número de elementos seja aproximadamente o mesmo em todos os segmentos. Em seguida, os elementos de cada segmento são ordenados por um método qualquer e então os segmentos ordenados são concatenados em ordem 24/03/2017 vladimir.professor@gmail.com

Bucket Sort - Utilização Este método pode ser utilizado em conjunto com outros métodos para realizar a separação de um problema grande em vários problemas pequenos, sendo mais simples de ordenar pelos métodos anteriormente descritos 24/03/2017 vladimir.professor@gmail.com

ShackerSort 24/03/2017 vladimir.professor@gmail.com

ShackerSort 24/03/2017 vladimir.professor@gmail.com

ShackerSort - Utilização 24/03/2017 vladimir.professor@gmail.com

ShackerSort - Utilização 24/03/2017 vladimir.professor@gmail.com

ShackerSort - Utilização 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

ShellSort 24/03/2017 vladimir.professor@gmail.com

Algoritmos de Ordenação São Paulo, 2010 Universidade Paulista (UNIP) Algoritmos de Ordenação Prof. MSc. Vladimir Camelo Vladimir.professor@gmail.com 24/03/2017 vladimir.professor@gmail.com