UNIVERSIDADE ESTADUAL DE PONTA GROSSA SETOR DE CINCIAS AGRRIAS E DE TECNOLOGIA DEPARTAMENTO DE INFORMTICA

RAMN DAMIN ARVALOS VILLALBA FABIO LUIZ SANTOS SILVA

ALGORITMOS DE ORDENAO NO TRIVIAIS

PONTA GROSSA 2011 RAMN DAMIN ARVALOS VILLALBA

FABIO LUIZ SANTOS SILVA

ALGORITMOS DE ORDENAO NO TRIVIAIS Trabalho de pesquisa apresentado para obteno de nota parcial na Universidade Estadual de Ponta Grossa, rea de Informtica. Orientadora: Prof. Dra. Tatiana Montes Celinski

PONTA GROSSA 2011

1 GNOME SORT

Gnome sort foi originalmente proposto por Hamid Sarbazi-Azad, em 2000 e chamado de stupid sort. Posteriormente foi descrito por Dick Grune e denominado "Gnome sort". Gnome sort um algoritmo de ordenao que semelhante ao ao Insertion sort com a diferena que o Gnome sort leva um elemento para sua posio correta, com uma seqencia grande de trocas assim como o Bubble sort. O algoritmo percorre o vetor comparando seus elementos dois a dois, assim que ele encontra um elemento que est na posio incorreta, ou seja, um nmero maior antes de um menor, ele troca a posio dos elementos, e volta com este elemento at que encontre o seu respectivo lugar. descrita por Dick. - Dick Grune - um conceito simples, sem necessidade de loops aninhados. O tempo de execuo O ( n ), mas tende a O ( n ) se a lista inicial esta quase classificado. Na prtica, o algoritmo pode correr to rpido como Insertion sort. O tempo de execuo mdio de O ( n 2 ) . O algoritmo encontra sempre o primeiro lugar onde os dois elementos adjacentes esto na ordem errada, e os swaps. Ele tira proveito do fato de que as realizaes de um swap podem introduzir um novo par adjacente fora-de-ordem justo antes ou depois de os dois elementos trocados. Ele no assume que os elementos a frente da posio atual so classificadas, de modo que apenas necessita de verificar a posio imediatamente antes dos elementos trocados. Caractersticas Classe Estrutura de Dados Caso de pior desempenho Caso de melhor desempenho Media do desempenho do caso Pior caso espao complexo Seleo de algoritmo Array O(n2) O(n) O(n2) O (1) auxiliar O nome vem do suposto comportamento dos holandeses garden gnome na classificao de uma linha de vasos de plantas e

Cdigo em C

# # # # #

include include include include include

<stdio.h> <stdlib.h> <ctype.h> <string.h> <stdbool.h>

# define MAX 100001 int VectorSort[MAX]; int size = 0; void swap(int * ,int *); void GnomeSort(); int main (void) { while(scanf("%d",&VectorSort[size]) >= 1) size++; GnomeSort(); } return 0;

void swap(int *A, int *B) { int C = *A; *A = *B; *B = C; } void GnomeSort() { int next = 0, previous = 0; int i = 0; for(i = 0; i < size ; i++) { if(VectorSort[i] > VectorSort[i + 1]) { previous = i; next = i + 1; while(VectorSort[previous] > VectorSort[next]) { swap(&VectorSort[previous],&VectorSort[next previous--; next--; } } for(i = 0; i < size; i++) printf("%d\n",VectorSort[i]); } }

]);

Otimizao

O tipo gnome sort pode ser otimizado atravs da introduo de uma varivel para armazenar a posio antes de atravessar em direo ao incio da lista. Isso permitiria o "gnomo" de se teletransportar de volta para sua posio anterior, depois de mover um vaso de flores. Com essa otimizao, o tipo gnome sort seria uma variante de insertion sort.

2 COUNTING SORT
Em cincia da computao, count sort um algoritmo para classificar uma coleo de objetos de acordo com as chaves que so pequenos inteiros , ou seja, um nmero inteiro de classificao do algoritmo. Ela opera atravs da contagem do nmero de objetos que possuem cada valor de chave diferente, e usando a aritmtica sobre essas acusaes para determinar as posies de cada valor de chave na seqncia de sada. Seu tempo de execuo linear no nmero de itens e a chave de valor mximo, por isso s adequado para uso direto em situaes em que as chaves no so significativamente maiores do que o nmero de itens. No entanto, frequentemente utilizado como uma sub-rotina de outro algoritmo de ordenao, radix sort, que pode lidar com chaves maiores de forma mais eficiente. Como a contagem de classificao usa valores essenciais como os ndices em uma matriz, no uma comparison sort, e o ( n log n ) lower bound (limite inferior) para ordenao de comparao, inaplicvel a ele. Bucket sort pode ser usado para muitos das mesmas tarefas como a contagem de classificao, com um tempo de anlise semelhante, porm, em relao contagem de classificao, uma espcie de segmento exige listas ligadas, matrizes dinmicas ou uma grande quantidade de memria pr-alocado para armazenar os conjuntos de itens dentro de cada segmento. Counting sort um algoritmo de ordenao estvel cuja complexidade O(n). As chaves podem tomar valores entre 0 e M-1. Se existirem k0 chaves com valor 0, ento ocupam as primeiras k0 posies do vetor final: de 0 a k0-1. Counting sort Classe Estrutura de Dados Algoritmo de ordenao Array, Listas ligadas

Complexidade pior caso O(n + k) Complexidade caso mdio O(n + k) Complexidade melhor caso O(n + k)

Entrada e sada de pressupostos No caso mais geral, a entrada para counting sort consiste de uma coleo de n itens, cada um dos quais tem uma chave no-negativo, cujo valor mximo no mximo k. Em algumas descries de counting sort, a entrada a ser classificado assumido como sendo mais simplesmente uma seqncia de inteiros em si, mas essa simplificao no acomoda muitas aplicaes de counting sort. Em aplicaes como em radix sort, um valor limite mximo k na chave ser conhecido com antecedncia, e pode ser considerado como parte da entrada para o algoritmo. No entanto, se o valor de k no conhecido j, ento ele pode ser calculado por uma ala adicional sobre os dados para determinar a chave do valor mximo que realmente ocorre dentro dos dados. A sada uma matriz dos itens, na ordem de suas chaves. Devido a aplicao de counting radix, importante para counting sort para ser uma espcie estvel: se dois elementos tm a mesma chave de outro, eles devem ter a mesma posio relativa na sada como fizeram na entrada. O algoritmo Em resumo, o algoritmo faz um loop sobre os itens, calcula um histograma do nmero de vezes que cada chave ocorre dentro da coleo de entrada. Em seguida, realiza um clculo soma prefixo (uma segunda volta, em toda a gama de chaves possveis) para determinar, para cada tecla, a posio de partida na matriz de sada dos itens com essa chave. Finalmente, ele faz um loop sobre os itens novamente, movendo-se cada item em sua posio ordenada. Anlise Porque o algoritmo usa apenas anlises simples para loops, sem recurso ou chamadas de sub-rotina. A inicializao da matriz de Contagem, e o segundo para o loop que executa uma soma de prefixo na matriz contam, cada iterao no mximo k + 1 vezes e, portanto, tomar tempo O ( k ). Os outros dois loops, e a inicializao

da matriz de sada, cada tomada S ( n ) tempo. Assim, o tempo para o algoritmo todo a soma dos tempos para essas etapas, O ( n + k ) . [ 1 ] [ 2 ] Porque ele usa matrizes de comprimento k + 1 e n, o uso do espao total do algoritmo tambm O (n + k ). Para os problemas fundamentais em que o valor mximo chave significativamente menor do que o nmero de itens, counting sort podem ser altamente espaco-eficiente, como o armazenamento apenas se outros usos que no a sua entrada e sada de matrizes a matriz de Contagem, que usa o espao S ( k ). Algoritmos Variantes Se cada item a ser classificado em si um nmero inteiro, e as teclas so os mesmos que os itens, ento o segundo e terceiro ciclos de contagem de classificao pode ser combinado; no segundo ciclo, em vez de calcular a posio onde os itens com a chave i deve ser colocado na sada, basta acrescentar Contagem [i] cpias do nmero i para a sada. Este algoritmo tambm pode ser usado para eliminar a duplicao de chaves, substituindo a matriz de contagem com um vetor de bits que armazena um para uma chave que est na entrada e um zero de uma chave que no est presente. Para os dados em que a chave de tamanho mximo significativamente menor do que o nmero de itens de dados, contagem de classificao pode ser paralelizada dividindo a entrada em submatrizes de tamanho aproximadamente igual, cada subarray processamento em paralelo para gerar uma matriz de contagem separada para cada subarray e em seguida, a fuso das matrizes de contagem. Quando utilizado como parte de um algoritmo de ordenao radix paralelo, o tamanho da chave (base da representao radix) deve ser escolhida para coincidir com o tamanho da diviso subarrays. A simplicidade do algoritmo de classificao, a contagem e seu uso da soma de seu fcil prefixo paralelizvel primitivo tambm torna-o utilizvel em mais refinados algoritmos paralelos. Conforme descrito, a contagem de classificao no um algoritmo de lugar, mesmo desconsiderando a matriz de contagem, que necessita de entrada separada e matrizes de sada. possvel modificar o algoritmo para que ele coloque os itens em ordem de classificao dentro da mesma matriz que lhe foi dado como entrada,

usando apenas a contagem de matriz como armazenamento auxiliar, no entanto, a verso modificada em espcie de contagem no estvel. Histria Embora a radix sorting se remonta a muito tempo, a counting sort, e suas aplicaes para radix sorting, foram inventados por Harold H. Seward , em 1954. Implementaes 1. Cria cnt[M+1] e b[max N] 2. Inicializa todas as posies de cnt a 0. 3. Percorre o vector a e, para cada posio i de a faz cnt[a[i]+1]++ o que faz com que, no final, cada posio i de cnt contem o n de vezes que a chave i-1 aparece em a. 4. Acumula em cada elemento de cnt o elemento somado ao elemento anterior: cnt[i] indica a posio ordenada do primeiro elemento de chave i. 5. Guarda em b os valores de a ordenados de acordo com b[cnt[a[i]++]=a[i] 6. Copia b para a. 7. Counting-Sort trabalha como uma contadora de ocorrncias dentro de um programa, especificamente dentro de um vetor. Quando determinado vetor tem nmeros repetidos, nmeros nicos e nmeros que no existem um outro vetor indica a quantidade de ocorrncias. Esta implementao tem a desvantagem de precisar de vetores auxiliares. Cdigo em C
# # # # include include include include <stdio.h> <string.h> <stdlib.h> <ctype.h>

# define MAX 100001 struct data { int number; char key[100]; }DataBase[MAX], VectorSort[MAX]; int CounterNum[MAX]; int size = 0; int main (void) {

int i = 0; while(scanf("%d%s",&DataBase[size].number,DataBase[size].key) >= 1) size++; int aux[2] = {0,0}; for(i = 0; i <= size;i++) aux[DataBase[i].number]++; aux[1] += aux[0]; for(i = size - 1;i >= 0;i--) VectorSort[--aux[DataBase[i].number]] = DataBase[i]; for(i = 0; i < size;i++) printf("Number: %d --- Key: %s\n",VectorSort[i].number,VectorSort[i].key); } return 0;

3 BOGOSORT
Em cincia da computao, bogosort (tambm random sort , shotgun sort ou monkey sort) particularmente um algoritmo de classificao ineficaz . Seu uso apenas para fins educacionais, para contrast-lo com outros algoritmos mais realista. Um exemplo disso a tentativa de ordenar um baralho repetidamente jogando as cartas ao ar, junt-las aleatoriamente, e ento verificar se as cartas esto ordenadas. Seu nome veio do engraado termo quantum bogodynamics e, ultimamente, a palavra bogus. Outros nomes so bozo sort , blort sort e vai-na sort ou Estou com sort.. Seu nome vem da palavra falsa . Classe Estrutura de Dados Caso de pior desempenho Caso de melhor desempenho Caso de performance medio Complexidade pior caso espao Seleo de algoritmo Array O() O(n) O(n.n!) O(n)

Tempo de durao e denncia Este algoritmo de ordenao de natureza probabilstica. Se todos os elementos a serem ordenados so distintos, o nmero esperado de comparaes, no caso mdio assintoticamente equivalente a ( e - 1) n ! , e o nmero esperado de swaps no caso mdio igual a ( n - 1) n ! .O nmero esperado de swaps cresce mais rpido do que o nmero esperado de comparaes, porque os elementos no esto em ordem, isso geralmente ser descoberto depois de apenas algumas comparaes, no importa como muitos elementos existem, mas o trabalho de embaralhar a cobrana proporcional ao seu tamanho. No pior dos casos, o nmero de comparaes e trocas so ilimitadas, pela mesma razo que uma moeda atirada ao ar pode transformar-se cabea de qualquer nmero de vezes em uma fileira. Deve-se notar que com os algoritmos geradores de nmeros pseudoaleatrios, que tm um nmero finito de estados e no so realmente aleatrios, o algoritmo pode nunca terminar para certos conjuntos de valores a serem ordenados. Bogosort no um algoritmo de ordenao estvel. O melhor caso ocorre se a lista que consta j est classificado, neste caso o nmero esperado de comparaes n - 1 , e no em todas as trocas so realizadas. Para qualquer conjunto de tamanho fixo, a hora prevista de execuo do algoritmo limitado por muito mesmo motivo, o que o teorema do macaco infinito detm: h alguma probabilidade de conseguir o direito de permuta, para receber um nmero ilimitado de tentativas ele vai quase certamente , eventualmente, ser escolhido. No entanto, se um gerador de nmeros pseudo-aleatrios usado no lugar de uma fonte aleatria, mas isso pode nunca terminar, uma vez que estes apresentam um comportamento cclico de longo prazo.

Algoritmos relacionados Goro sort - um algoritmo de ordenao introduzido no 2011. Enquanto a lista no est em ordem, um subconjunto de todos os elementos aleatoriamente permutados. Se este subconjunto ideal escolhido cada vez que este executado,

o valor esperado do nmero total de vezes que esta operao tem de ser feito igual ao nmero de elementos perdidos. Bozo sort - outro algoritmo de classificao baseada em nmeros aleatrios. Se a lista no est em ordem, ele pega dois itens de forma aleatria e swaps destes, ento verifica se a lista ordenada. A anlise de tempo de execuo do Bozo de classificao mais difcil. O (n!) encontrado para ser o caso mdio esperado. Quantum bogosort uma piada interna entre alguns cientistas da computao que a computao quntica pode ser usada para implementar eficazmente um bogosort com uma complexidade de tempo O (n). Ele usa aleatoriedade quntica verdadeiro permutar aleatoriamente da lista. A lista ento inspecionada, e se no estiver em ordem, o universo destrudo. Implementaes C
void EstoucomSort(int size, int *array) { int i, j; for (i = 1; i <= size; i++) if (i == size) return; else if (array[i-1] > array[i]) break; for (i = 0; i < size; i++) { j = rand() % size; if (array[i] != array[j]) array[i] ^= array[j] ^= array[i] ^= array[j]; /* Mtodo de swap favorito de 10 entre 10 [[l33t]] POGers. */ } EstoucomSort(size, array); /* Estouro de pilha garantido para n >= 4. */ }

Fluxograma

4 COCKTAIL SORT
Cocktail sort, tambm conhecido como Shaker Sort, bubble sort bidirecional (que tambm pode se referir a uma variante do selection sort), ripple sort, shuttle sort ou happy hour sort, uma variao do bubble sort que tanto um algoritmo de ordenao estvel quanto uma ordenao por comparao. O algoritmo difere do bubble sort pelo fato de ordenar em ambas as direes em cada passagem atravs da lista. Este algoritmo de ordenao apenas ligeiramente mais difcil de programar do que o bubble sort, e resolve o problema com os chamados coelhos e tartarugas no bubble sort.

Classe

Seleo algoritmo Array (n )

Estrutura de dados Caso de pior desempenho Caso de melhor desempenho Caso media de desempenho

O (n)

(n )

A forma mais simples de classificar cocktail percorre toda a lista cada vez: O primeiro passo para a direita mudar o maior elemento para o seu lugar correto no final, e para a esquerda aps passar mudar o menor elemento para o seu lugar correto no incio. A segunda passagem completa mudar o segundo maior e o segundo menor elemento para seus lugares corretos, e assim por diante. Depois que i passar, o primeiro que i e os ltimos elementos i na lista esto em suas posies corretas, e no precisam ser verificados. Ao encurtar a parte da lista que classificado de cada vez, o nmero de operaes pode ser reduzido pela metade. Complexidade A complexidade do tipo coquetel em big O notation O ( n 2 ) para ambos, o pior caso e caso mdio, mas torna-se mais prximo de O ( n ) se a lista mais ordenada antes de aplicar o algoritmo de ordenao, por exemplo, se cada elemento est em uma posio que difere na maioria dos k (k 1) a partir da posio que vai acabar em, a complexidade do tipo cocktail torna-se O ( k * n ) . 1 + 1 + 1 + 1 + n(1 + n(1(1 + 1 + 1 + 1)) + 1 + n(1(1 + 1 + 1 + 1)) + 1) 4 + n(3 + 4n + 4n) 4 + n(3 + 8n)

n(n) O(n) Implementaes Cdigo em C

void cocktail_sort(int list[10]) { int length,bottom,top, swapped,i,aux; length=10; bottom = 0; top = length - 1; swapped = 0; while(swapped == 0 && bottom < top)//Se no houver troca de posies ou o ponteiro que { //sobe ultrapassar o que desce, o vetor esta ordenado swapped = 1; //Este for a ida para a direita for(i = bottom; i < top; i = i + 1) { if(list[i] > list[i + 1]) //indo pra direita:testa se o prximo maior { //indo pra direita:se o proximo maior que o atual, //troca as posies aux=list[i]; list[i]=list[i+1]; list[i+1]=aux; swapped = 0; } }//fecha for // diminui o `top` porque o elemento com o maior valor // j est na direita (atual posio top) top = top - 1; //Este for a ida para a esquerda for(i = top; i > bottom; i = i - 1) { if(list[i] < list[i - 1]) { aux=list[i]; list[i]=list[i-1]; list[i-1]=aux; swapped = 0; } } //aumenta o `bottom` porque o menor valor j est //na posio inicial (bottom) bottom = bottom + 1; }//fecha while }// fim da funao

5 TIMSORT
Timsort um algoritmo de ordenao hbrido derivado do merge sort e do insertion sort, projetado para ter bom desempenho em vrios tipos de dados do

mundo real. Foi inventado por Tim Peters em 2002 para ser usado na linguagem de programao Python, e tem sido o algoritmo de ordenao padro de Python desde a verso 2.3. Ele atualmente usado para ordenar arrays em Java SE 7. Tim Peters descreve o algoritmo da seguinte forma:
[...]um adaptativo, estvel, merge sort natural, modestamente chamado de timsort (hey, eu ganhei ele <wink>). Tem desempenho sobrenatural em muitos tipos de arrays parcialmente ordenados (menos de lg(N!) comparaes necessrias, e to poucas quanto N-1), no entanto, to rpido quanto o algoritmo anterior altamente sintonizado, hbrido, samplesort de Python em matrizes aleatrias. Em suma, a rotina principal passa sobre a matriz uma vez, da esquerda para a direita, alternadamente, identificando o prximo passo, em seguida, fundindo-os em passos anteriores "inteligentemente". Todo o resto complicao pela velocidade, e alguma medida duramente conquistada da eficincia de memria.

Classe Estrutura de Dados Caso de pior desempenho Caso de melhor desempenho Caso Media de desempenho Pior caso espao complexo Estabilidade

Seleo de algoritmo Array O ( n log n ) (n) ( n log n ) O(n) Estavel

Como o merge sort, um algoritmo de ordenao por comparao estvel com uma complexidade de pior caso de (nlogn). De acordo com a teoria da Informao, nenhuma ordenao por comparao pode executar em menos de log2(n!), no caso mdio, o que exige que a ordenao

por comparao tome um tempo de (nlogn) em dados aleatrios. No entanto, em dados do mundo real, o Timsort muitas vezes exige muito menos do que log2(n!), porque ele tira vantagem do fato de que sublistas dos dados podem j estar em ordem ou ordem inversa.

6 REFERNCIAS

GRUBER, H. et al. Sorting the Slow Way: An Analysis of Perversely Awful Randomized Sorting Algorithms. 4a International Conference on Fun with Algorithms, Castiglioncello, Italy, p. 183-197, 2007. JJB. Commit 6804124: Replace "modified mergesort" in java.util.Arrays.sort with timsort. Java Development Kit 7 Hg repo. Disponvel em: <http://hg.openjdk.java.net/jdk7/tl/jdk/rev/bfd7abda8f79>, acesso em: 15 jun. 2011. KNUTH, D. E. The Art of Computer Programmin. v. 3, 2 ed. Sorting and Searching: Addison-Wesley, p. 7580, 1998. PETERS, T. Sorting, 2002. Disponvel em: <http://mail.python.org/pipermail/pythondev/2002-July/026837.html>, acesso em 16 jun. 2011. PETERS, T. Timsort. Python Issue Tracker. Disponvel <http://bugs.python.org/file4451/timsort.txt>, acesso em: 16 jun. 2011. em:

RUNE, D. Gnome Sort The Simplest Sort Algorithm, 2000. Disponvel em: <http://dickgrune.com/Programs/gnomesort.html>, acesso em: 15 jun. 2011. SEWARD, H. H. Information sorting in the application of electronic digital computers to business operations. Master's thesis, Report R-232, Massachusetts Institute of Technology, Digital Computer Laboratory, pp. 2528,1954.

C la s s : ja v a .util.T im S or t<T> Android JDK 1.5 Documentation. Disponvel em: <http://www.kiwidoc.com/java/l/x/android/android/5/p/java.util/c/TimSort>, acesso em: 16 jun. 2011.

What is the Average Big-O Complexity of Gnome sort? <http://stackoverflow.com/questions/2066541/what-is-the-average-big-complexity-ofgnome-sort>, acesso em:15 jun. 2011.