Você está na página 1de 43

Ordenao (computao)

Origem: Wikipdia, a enciclopdia livre.

Ordenao o ato de se colocar os elementos de uma sequncia de informaes, ou dados, em uma ordem predefinida. O termo tcnico em ingls para ordenao sorting, cuja traduo literal "classificao". Dado uma seqencia de n dados:

O problema de ordenao uma permutao dessa seqencia

tal que

para alguma relao de ordem. Algumas ordens so facilmente definidas. Por exemplo, a ordem numrica, ou a ordem alfabtica -- crescentes ou decrescentes. Contudo, existem ordens, especialmente de dados compostos, que podem ser no triviais de se estabelecer. Um Algoritmo que ordena uma conjunto, geralmente representada num vetor, chamadado um algoritmos de ordenao. Entre os mais importantes, podemos citar bubble sort (ou ordenao por flutuao), heap sort (ou ordenao por heap), insertion sort (ou ordenao por insero), merge sort (ou ordenao por mistura) e o quicksort.

Ordenao estvel
Origem: Wikipdia, a enciclopdia livre.

Um algoritmo de ordenao diz-se estvel se preserva a ordem de registros de chaves iguais. Isto , se tais registros aparecem na sequncia ordenada na mesma ordem em que esto na sequncia inicial. Esta propriedade til apenas quando h dados associados s chaves de ordenao.
[1]

Exemplo
Por exemplo, um algoritmo estvel ordenando a sequncia de nmeros (chaves) com letras associadas (registros):

3[a], 2[b], 2[c], 1[d]

obrigatoriamente retornar:

1[d], 2[b], 2[c], 3[a]

enquanto algoritmos instveis sujeitam os elementos associados aos objetos a serem ordenados a mudanas:

1[d], 2[c], 2[b], 3[a]

Implementao
Certos algoritmos so estveis a partir de sua concepo original, como o Counting sort ou o Merge sort. Porm. possvel implementar estabilidade artificialmente em certos algoritmos. Por exemplo, numa comparao de dois objetos de mesmo valor pode aplicar-se uma comparao adicional para verificar se a ordem original dos registros associados foi mantida. Neste caso, a implementao de estabilidade requer um custo adicional de eficincia.

Algoritmos estveis
Alguns algoritmos de ordenao estveis:

Bubble sort Cocktail sort Insertion sort Merge sort Bucket sort

Algoritmos instveis
Alguns algoritmos de ordenao instveis:

Selection Sort Quick Sort Heap Sort Shell Sort Counting Sort

Algoritmo de ordenao
Origem: Wikipdia, a enciclopdia livre.

Algoritmo de ordenao em cincia da computao um algoritmo que coloca os elementos de uma dada sequncia em uma certaordem -- em outras palavras, efetua sua ordenao completa ou parcial. As ordens mais usadas so a numrica e a lexicogrfica. Existem vrias razes para se ordenar uma sequncia. Uma delas a possibilidade se acessar seus dados de modo mais eficiente.

Mtodos de ordenao de vetores


Mtodos simples

Insertion sort Selection sort Bubble sort Comb sort

Mtodos sofisticados

Quick sort

Merge sort Heapsort Shell sort Radix sort Gnome sort Count sort Bucket sort Cocktail sort Timsort

Mtodos de pesquisa

Pesquisa binria Busca linear BogoBusca

Bogosort
Origem: Wikipdia, a enciclopdia livre.

Bogosort (tambm denominado bozo sort, blort sort e vai-na sort ou Estou com sort) um algoritmo de ordenao extremamente ineficiente, baseado na reordenao aleatria dos elementos. No utilizado na prtica, mas pode ser usado no ensino de algortmos mais eficientes. Seu nome veio do engraado termo quantum bogodynamics e, ultimamente, a palavra bogus. Esse algoritmo probabilstico por natureza. Se todos os elementos a serem ordenados so distintos, a complexidade esperada . O tempo exato de execuo esperado depende do quantos diferentes valores de elementos

ocorrem, e quantas vezes cada um deles ocorre, mas para casos no-triviais o tempo esperado de execuo exponencial ou super-exponencial a . Ele termina pela mesma razo do teorema do macaco infinito; existe alguma probabilidade de que

acontea a permutao correta, dado que em um infinito nmero de tentativas fatalmente a encontrar. Deve-se notar que com os algoritmos geradores de nmeros pseudo-aleatrios, 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.

Exemplo
Para se ordenar um baralho usando-se este algortmo, seria necessrio jogar as cartas ao ar, junt-las aleatoriamente, e ento verificar se as mesmas esto ordenadas.
[editar]Algortmo

funo bogosort(array)

enquanto no est_ordenado(array) array := permutao_aleatria(array)


[editar]Implementaes [editar]C

void bogosort(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]; } bogosort(size, array); }
[editar]C++

#include <algorithm> #include <vector> template<class T> void bogosort(std::vector<T>& array) { while (! is_sorted(array)) std::random_shuffle(array.begin(), array.end()); } template<class T> bool is_sorted(const std::vector<T>& array) { for (typename std::vector<T>::size_type i = 1; i < array.size(); ++i) if (array[i] < array[i-1]) return false; return true; }
[editar]Java

public static void bogoSort(int length, int range) { int []array = randomIntArray(length,range); while (! isSorted(array)) array = randomArray(array); for (int i = 0; i < array.length; i++) { System.out.print(array[i] + " "); }

} private static boolean isSorted(int [] array) { for (int i = 0; i < (array.length - 1); ++i) { if (array[i] > array[i+1]) return false; } return true; } private static int [] randomArray(int [] array) { int size = array.length; int[] indices = new int[size]; for (int i=0; i<size; i++) { indices[i] = i; } Random random = new Random(); for (int i = 0; i < size; i++) { boolean unique = false; int nRandom = 0; while (!unique) { unique = true; nRandom = random.nextInt(size); for (int j = 0; j < i; j++) { if (indices[j] == nRandom) { unique = false; break; } } } indices[i] = nRandom; } int [] result = new int[size]; for (int k = 0; k < size; k++) { result[indices[k]] = array[k]; } return result; } private static int[] randomIntArray(int length, int n) { int[] a = new int[length]; Random generator = new Random(); for (int i = 0; i < a.length; i++) { a[i] = generator.nextInt(n);

} return a; }

Fluxograma

Introduo
O bubble sort, ou ordenao por flutuao (literalmente "por bolha"), um algoritmo de ordenao dos mais simples. A ideia percorrer o vector diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da sequncia. Essa movimentao lembra a forma como as bolhas em um tanque de gua procuram seu prprio nvel, e disso vem o nome do algoritmo. No melhor caso, o algoritmo executa operaes relevantes, onde n representa o nmero de elementos do vector. No pior caso, so

feitas operaes. A complexidade desse algoritmo de Ordem quadrtica. Por isso, ele no recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados. [editar]Algoritmo [editar]Pseudo-cdigo O algoritmo abaixo, decrito em pseudo-cdigo, promete ordenar um vetor V[1..n] em ordem crescente.

Algoritmo Bubble(V, n) 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. k = k-1 k = n-1 para i = 1 at n faa j = 1 enquanto j <= k faa se V[j] > V[j+1] ento aux = V[j] V[j] = V[j+1] V[j+1] = aux j = j+1

[editar]Demonstrao

de corretude

A demonstrao do algoritmo se apia nos seguintes invariantes, provados por induo matemtica:

(i0): na linha 2, V[n-i+2 .. n] crescente.

Prova: no momento da entrada do lao externo, quando i=1, o invariante vale, j que V[n+1 .. n] vazio e, portanto, crescente. Suponha agora que o invariante vale se trocarmos i por i-1. Queremos mostrar que ele tambm vale para i. Por hiptese de induo, V[n-i+3 .. n] crescente. Pelo invariante (i1), ao terminar o lao das linhas 4-9, teremos que V[1 .. n-i] <= V[n-i+1]. V[n-i+2] <= V[n-i+3 .. n]. Assim, V[n-i+2 .. n] crescente. Observe que a validade de (i0) em conjunto com a condio de parada do algoritmo (i = n+1) implicam na corretude do mesmo: V[n(n+1)+2 .. n] = V[1 .. n] crescente.

(i1): na linha 4, vale que V[ j ] >= V[1 .. j-1]

Prova: o invariante vale na entrada do lao das linhas 4-9, quando j=1, pois V[1] >= V[1..0] (vazio). Suponha agora que o invariante vale se trocarmos j por j-1. Ento, V[ j-1 ] >= V[1 .. j-2] na linha 4. Ora, mas podemos ver que, ao final do lao interno, V[ j ] >= V[ j-1 ]. De fato, na linha 5, se V[ j-1 ] > V[ (j-1)+1 ] = V[ j ], trocaremos V[ j-1 ] e V[ j ] de posio, o que garante que V[ j ] >= V[ j-1 ] sob qualquer circunstncia. Observe que, ao final do lao interno, V[n-i+1] >= V[1 .. n-i]: aplique (i1) com j = k+1, notando que k = n-i. [editar]Anlise

do consumo de tempo

TODO. Algum saberia formatar melhor esta tabela?

-------------+------------------------------------linha 1 2 3 4 5 6 7 8 9 10 total | nmero de execues da linha 1 n+1 n n sum_{i=1}^{n} n-i+1 = (n^2 + n)/2 + 1 <= sum_{i=1}^{n} n-i = (n^2 + n)/2 <= sum_{i=1}^{n} n-i = (n^2 + n)/2 <= sum_{i=1}^{n} n-i = (n^2 + n)/2 sum_{i=1}^{n} n-i = (n^2 + n)/2 n <= (5/2)n^2 + (13/2)n + 3 -------------+-------------------------------------

-------------+-------------------------------------------------+-------------------------------------

O consumo de tempo de Bubble \theta(n^2). TODO: provar. [editar]Verso

alternativa

Abaixo h um algoritmo Bubble Sort onde a implementao a mais simples possvel, ou seja, a verso original do Bubble Sortsem o aprimoramento da varivel "houve troca".

BUBBLESORT (V[], n) houveTroca <- verdade enquanto houveTroca for verdade faa: houveTroca <- falso para i de 1 at n-1 faa: se V[i] vem depois de V[i + 1] # uma varivel de controle

ento troque V[i] e V[i + 1] de lugar e houveTroca <- verdade

Para j de 1 at (i - 1) Passo 1 Se a[j - 1] > a[j] Ento aux <- a[j] a[j] <- a[j - 1] a[j - 1] <- aux FimSe

Observao: Neste algoritmo tanto o melhor caso, como o pior caso tem ordem "n", porque em ambos os casos os ciclos so sempre realizados at ao fim, mesmo quando os elementos j esto ordenados.

[editar]Implementao [editar]C 1. include<stdio.h> 2. include<stdlib.h> 3. include<conio.h> 4. include<stdbool.h> int main() {

int vetor[5], i, aux; bool parar = false; for(i=0;i<5;++i) { printf("Digite o valor: "); scanf("%d",&vetor[i]); } while(parar == false) { parar = true; for(i=0;i<4;++i) { if(vetor[i]>vetor[i+1]) { parar = false; aux = vetor[i]; vetor[i] = vetor[i+1]; vetor[i+1] = aux; } } }

for(i=0;i<5;++i) { printf("%d",vetor[i]); } getch(); return 0;

} [editar]Java public static void bubbleSort (int [] vetor){ boolean houveTroca = true; while (houveTroca) { houveTroca = false; for (int i = 0; i < (vetor.length)-1; i++){ if (vetor[i] > vetor[i+1]){ int variavelAuxiliar = vetor[i+1]; vetor[i+1] = vetor[i]; vetor[i] = variavelAuxiliar; houveTroca = true; } } } } [editar]C Usando "do while". void swapbubble( int v[], int i) { int aux=0; aux=v[i]; v[i] = v[i+1]; v[i+1] = aux; } void bubble(int v[], int qtd) { int i; int trocou; qtd--; do { trocou = 0; for(i = 0; i < qtd; i++) { if(v[i] > v[i + 1])

{ swapbubble(v, i); trocou = 1; } } }while(trocou); } Mtodo de ordenao Bolha com ordenao de strings.

void bubble(int v[], int qtd) //UTILIZA BIBLIOTECA string.h { int i; int trocou; char aux; do { qtd--; trocou = 0; for(i = 0; i < qtd; i++) if(strcasecmp(v[i],v[i + 1])>0) { /*o ideal seria fazer uma funo troca aqui*/ strcpy(aux, v[i]); strcpy(v[i], v[i + 1]); strcpy(v[i + 1], aux); trocou = 1; } }while(trocou==1); } [editar]C++ #include <algorithm> using namespace std; void bubblesort(int a[], int n) { for(int j=0; j<n; j++){ for(int i=0; i<n-1; i++){ if(a[i+1] < a[i]) swap(a[i+1], a[i]); } } }

[editar]Fluxograma

Bucket sort

Conceito de base do bucket sort.

Bucket sort, ou bin sort, um algoritmo de ordenao que funciona dividindo um vetor em um nmero finito de recipientes. Cada recipiente ento ordenado individualmente, seja usando um algoritmo de ordenao diferente, ou usando o algoritmo bucket sort recursivamente. O bucket sort tem complexidade linear ((n)) quando o vetor a ser ordenado contm valores que so uniformemente distribudos.
[editar]Funcionamento

Bucket sort funciona do seguinte modo: 1. Inicialize um vetor de "baldes", inicialmente vazios. 2. V para o vetor original, incluindo cada elemento em um balde. 3. Ordene todos os baldes no vazios. 4. Coloque os elementos dos baldes que no esto vazios no vetor original.
[editar]Exemplo

em C

//Compilado em Linux.Sujeito a mudanas caso outro sistema seja utilizado. #include <stdio.h> #define tam_bucket 100 #define num_bucket 10 #define max 10 typedef struct { int topo; int balde[tam_bucket]; }bucket; void bucket_sort(int v[],int tam); void bubble(int v[],int tam); //int main(){} void bucket_sort(int v[],int tam){ bucket b[num_bucket]; int i,j,k; /* 1 */ for(i=0;i<num_bucket;i++) b[i].topo=0; /* 2 */ for(i=0;i<tam;i++){ ficar j=(num_bucket)-1; while(1){ if(j<0) break; if(v[i]>=j*10){ b[j].balde[b[j].topo]=v[i]; (b[j].topo)++; break; } j--; } //verifica em que balde o elemento deve //inicializa todos os "topo" //cabealho das funes

} /* 3 */ for(i=0;i<num_bucket;i++) if(b[i].topo) bubble(b[i].balde,b[i].topo); i=0; /* 4 */ for(j=0;j<num_bucket;j++){ no vetor for(k=0;k<b[j].topo;k++){ v[i]=b[j].balde[k]; i++; } } } void bubble(int v[],int tam){ int i,j,temp,flag; if(tam) for(j=0;j<tam-1;j++){ flag=0; for(i=0;i<tam-1;i++){ if(v[i+1]<v[i]){ temp=v[i]; v[i]=v[i+1]; v[i+1]=temp; flag=1; } } if(!flag) break; } }
[editar]Explicao

//ordena os baldes

//pe os elementos dos baldes de volta

do cdigo

Bucket sort - fase 1.

Bucket sort - fase 2.

Antes de mais nada, preciso saber o que cada "#define" significa. 1. 2. 3. tam_bucket o tamanho de cada balde da estrutura bucket. num_bucket o nmero de baldes, isto , o tamanho do vetor de bucket max o tamanho do vetor a ser ordenado.

A estrutura bucket consiste de um vetor de inteiros (int balde[tam_bucket]) e de uma varivel que serve para dizer quantos nmeros esto armazenados no balde. O parmetro "tam", tanto na funo "bucket_sort" como na "bubble", o tamanho do vetor a ser ordenado. A explicao dos "for" agora: 1. Inicializa o "topo" de cada bucket que o vetor de bucket "b[num_bucket]" contm.

Isso importante, pois, a princpio, os baldes esto vazios. 2. Verifica em que balde o elemento deve ficar.

Cada elemento do vetor a ser ordenado colocado em seu lugar no vetor de bucket.Por exemplo, suponha o nmero 26.A varivel "j" receberia (num_bucket-1), isto ,9 no exemplo acima.O "while" verifica se 26 maior do que j*10 (90).Como isto no vlido, "j" decrementado em 1, e o processo se repete at que j=2, j que 26>=20.Ento, o balde de posio 2 recebe 26.Caso no haja nenhum outro elemento no balde 2, isso significa que "topo" daquele balde vale 0, portanto balde[0] recebe o 26.Caso haja, por exemplo, 3 elementos no balde, isso quer dizer que topo=2, portanto balde[2] recebe 26.Depois disso, "topo" daquele balde incrementado em 1 e o processo se repete para os outros elementos do vetor que queremos ordenar. 3. Ordena cada balde.

Ordena os baldes cujos "topo" so diferentes de 0, ou seja, no esto vazios.No algoritmo acima, o bubble sort foi utilizado, mas mtodos mais eficientes podem ser utilizados. 4. Por fim, os baldes so percorridos e seus elementos so devolvidos para o vetor original.

Atente para o fato de que nosso exemplo no ordena elementos negativos.Um tratamento especial para eles seria necessrio.Alm do mais, o mtodo de separar cada elemento pode ser diferente.O utilizado foi verificar se o elemento est entre 0 e 10, 11 e 20, e assim por diante. _______________________________________________________________________________________ ____ Aqui uma matriz linear de inteiros com n elementos, usado para ordenar os elementos do vetor.
[editar]Exemplo

em C++ com matriz

/*************************INICIO*****************************************/ //================================================================== // // // // // // //================================================================== #include <iostream> #define TAM 20 /*Tamanho do vetor*/ Projeto: Bucket Sort Data de Criacao: 27/02/09 Autor: Albany Timbo Mesquita Colaboracao:Pedro Henrique Fernandes Marques Leitao

#define NUM 10000 /*base para gerador de numeros aleatorios*/ using std::cout; using std::cin; using std::endl; void gerarVet(int*); void bucketSort(int*); void imprimaVet(int*); int main(){ int vet[TAM],tinicio,tfim,tempo; tinicio=time(NULL); gerarVet(vet); imprimaVet(vet); bucketSort(vet); imprimaVet(vet); tfim=time(NULL); tempo=difftime(tfim,tinicio); cout<<"Tempo de execucao "<<tempo/60<<" Minutos e "<<tempo%60<<" segundos.\n"; system("pause"); return 0; } /***********************************************************************/ /*******************************FUNCOES*********************************/ /***********************************************************************/ void bucketSort(int *vet){ int mat[10][TAM],aux[TAM],cont=1,num,w=0,i,j;

do{ for(i=0;i<TAM;i++){aux[i] = 0;}//Zerando o vetor auxiliar. for(i=0;i<10;i++) {//Setando a Matriz com valores -1 for(j=0;j<TAM;j++){ mat[i][j] = -1; } } for (i=0;i<TAM;i++) { num = (vet[i]/cont)%10;//verificando o valor da esquerda para direita mat[num][aux[num]] = vet[i];//colocando o valor na sua posicao na matriz aux[num]++; //contador de colunas da matriz } for(i=0;i<10;i++) {//volta com os valores da Matriz para o vetor for(j=0;j<TAM;j++){ if(mat[i][j] != -1){ vet[w] = mat[i][j]; w++; }

} } w = 0; cont=cont*10; }while(aux[0] < TAM);//condicao :Enquanto vetor auxiliar < tamanho vetor } //

/******************GERADOR DE NUMEROS ALEATORIOS**************************/ void gerarVet(int *vet){ srand(time(NULL)); for (int i=0;i<TAM;i++){ vet[i]=rand()%NUM; } } /*******************FUNCAO PARA IMPRIMIR VETOR************************/ void imprimaVet(int *vet){ for (int i=0;i<TAM;i++){ cout<<vet[i]<<"|"; } cout<<"**************************************************************\n"; } /********************************FIM*************************************/ _______________________________________________________________________________________ ______________________
[editar]Exemplo

em Java com LinkedList

/* * Autor: wilhs * Data: 28/04/2011 * Crdito: Implementao com base neste Artigo. */ public static void BucketSort(int[] vetor, int maiorValor) { int numBaldes = maiorValor/5; LinkedList[] B = new LinkedList[numBaldes]; for (int i = 0; i < numBaldes; i++){ B[i] = new LinkedList<Integer>(); } //Coloca os valores no balde respectivo: for (int i = 0; i < vetor.length; i++) { int j = numBaldes-1; while (true){ if(j<0){ break; } if(vetor[i] >= (j*5)){ B[j].add(vetor[i]); break;

} j--; } } //Ordena e atualiza o vetor: int indice = 0; for (int i = 0; i < numBaldes; i++){ int[] aux = new int[B[i].size()]; //Coloca cada balde num vetor: for (int j = 0; j < aux.length; j++){ aux[j] = (Integer)B[i].get(j); } insertionSort(aux); //algoritmo escolhido para ordenao. // Devolve os valores ao vetor de entrada: for (int j = 0; j < aux.length; j++, indice++){ vetor[indice] = aux[j]; } } }

Cocktail sort
Origem: Wikipdia, a enciclopdia livre.

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 ouhappy hour sort, uma variao do bubble sort que tanto um algoritmo de ordenaoestvel 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 implementar do que o bubble sort, e resolve o problema com os chamados coelhos e tartarugas no bubble sort.
[editar]Complexidade

O(n)
[editar]Implementaes [editar]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]) { //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
[editar]Cdigo

//indo pra direita:testa se o prximo maior

//indo pra direita:se o proximo maior que o atual,

em C# e Java (sintaxe idntica)

private static void cocktail(int[] vetor) { int tamanho, inicio, fim, swap, aux; tamanho = 20; // para um vetor de 20 elementos inicio = 0; fim = tamanho - 1; swap = 0; while (swap == 0 && inicio < fim) { swap = 1; for (int i = inicio; i < fim; i = i + 1) { if (vetor[i] > vetor[i + 1]) { aux = vetor[i]; vetor[i] = vetor[i + 1];

vetor[i + 1] = aux; swap = 0; } } fim = fim - 1; for (int i = fim; i > inicio; i = i - 1) { if (vetor[i] < vetor[i - 1]) { aux = vetor[i]; vetor[i] = vetor[i - 1]; vetor[i - 1] = aux; swap = 0; } } inicio = inicio + 1; } }

Comb sort
Origem: Wikipdia, a enciclopdia livre.

O algoritmo Comb sort (ou Combo sort ou ainda algoritmo do pente[1]) umalgoritmo de ordenao relativamente simples, e faz parte da famlia de algoritmos deordenao por troca. Foi desenvolvido em 1980 por Wlodzimierz Dobosiewicz. Mais tarde, foi redescoberto e popularizado por Stephen Lacey e Richard Box em um artigo publicado na revista Byte em Abril de 1991. O Comb sort melhora o Bubble sort, e rivaliza com algoritmos como o Quicksort. A idia bsica eliminar as tartarugas ou pequenos valores prximos do final da lista, j que em um bubble sort estes retardam a classificao tremendamente. (Coelhos, grandes valores em torno do incio da lista, no representam um problema no bubble sort). O Algoritmo repetidamente reordena diferentes pares de itens, separados por um salto, que calculado a cada passagem. Mtodo semelhante ao Bubble Sort, porm mais eficiente. Na Bubble sort, quando quaisquer dois elementos so comparados, eles sempre tm um gap (distncia um do outro) de 1. A idia bsica do Comb sort que a diferena pode ser muito mais do que um. (O Shell sort tambm baseado nesta idia, mas uma modificao do insertion sort em vez do bubble sort). O gap (intervalo) comea como o comprimento da lista a ser ordenada dividida pelo fator de encolhimento (em geral 1,3; veja abaixo), e a lista ordenada com este valor (arredondado para um inteiro se for necessrio) para o gap. Ento, a diferena dividida pelo fator de encolhimento novamente, a lista ordenada com este novo gap, e o processo se repete at que a diferena seja de 1. Neste ponto, o Comb sort continua usando um espao de 1 at que a lista esteja totalmente ordenada. A fase final da classificao , portanto, equivalente a um bubble sort, mas desta vez a maioria dos elementos "tartarugas" j foram tratados, assim o bubble sort ser eficiente.
[editar]Fator

de encolhimento

O fator de encolhimento tem um grande efeito sobre a eficincia do Comb sort. No artigo original, os autores sugeriram 1,3 depois de tentar algumas listas aleatrias e encontrando-se, geralmente as mais eficazes. Um valor muito pequeno retarda o algoritmo porque mais comparaes devem ser feitas, ao passo que um valor muito grande no pode tratar um nmero suficiente de "tartarugas" para ser prtico.

O texto descreve uma melhoria no comb sort usando o valor base

como

fator de encolhimento. Ele tambm contm uma implementao em pseudocdigo com uma tabela de gaps pr-definidos.
[editar]Variaes [editar]Combsort11

Com um fator de encolhimento de cerca de 1,3, s existem trs caminhos possveis para a lista de gaps terminar: (9, 6, 4, 3, 2, 1), (10, 7, 5, 3, 2, 1), ou (11, 8, 6, 4, 3, 2, 1). Experimentos mostram que melhorias significativas de velocidade podem ser feitas se o gap for definido como 11, sempre que, caso contrrio, tornar-se 9 ou 10. Esta variao chamada Combsort11. Se uma das sequncias que comeam com 9 ou 10, forem utilizadas, o passo final, com um intervalo de 1 tem menor probabilidade de ordenar os dados sendo necessrio ento outro passo com gap de 1. Os dados so ordenados quando no ocorrem mais trocas durante uma passagem com gap= 1. Tambm possvel usar uma tabela pr-definida, para escolher quais gaps a utilizar em cada passo.
[editar]Combsort

com diferentes finais

Como muitos outros algoritmos eficientes de ordenao (como o quick sort ou merge sort), o comb sort mais eficaz em suas passagens anteriores do que durante o passo final, quando ele se assemelha a um bubble sort. O Comb sort pode ser mais eficaz se o mtodo de classificao mudado uma vez que os gaps cheguem a um nmero pequeno o suficiente. Por exemplo, uma vez que a diferena chegue a um tamanho de cerca de 10 ou menor, parando o comb sort e fazendo um simples gnome sort ou cocktail sort, ou, melhor ainda, um insertion sort, se aumentar a eficincia global da ordenao. Outra vantagem deste mtodo que no h necessidade de manter o controle das operaes de troca durante os passos da classificao para saber se a ordenao deve parar ou no.
[editar]Implementaes [editar]C++

Esta uma implementao no estilo STL. Ele ir classificar qualquer intervalo entre a primeira e a ltima. Isso funciona com quaisqueriteradores posteriores, mas mais eficaz com iteradores de acesso aleatrio ou ponteiros. template<class ForwardIterator> void combsort ( ForwardIterator first, ForwardIterator last ) { static const double shrink_factor = 1.247330950103979; typedef typename std::iterator_traits<ForwardIterator>::difference_type difference_type; difference_type gap = std::distance(first, last); bool swaps = true; while ( (gap > 1) || (swaps == true) ){ if (gap > 1) gap = static_cast<difference_type>(gap/shrink_factor); swaps = false; ForwardIterator itLeft(first); ForwardIterator itRight(first); std::advance(itRight, gap); for ( ; itRight!=last; ++itLeft, ++itRight ){ if ( (*itRight) < (*itLeft) ){ std::iter_swap(itLeft, itRight);

swaps = true; } } } }
[editar]Java

public static <E extends Comparable<? super E>> void sort(E[] input) { int gap = input.length; boolean swapped = true; while (gap > 1 || swapped) { if (gap > 1) gap = (int) (gap / 1.247330950103979); int i = 0; swapped = false; while (i + gap < input.length) { if (input[i].compareTo(input[i + gap]) > 0) { E t = input[i]; input[i] = input[i + gap]; input[i + gap] = t; swapped = true; } i++; } } }
[editar]C

void combsort(int *arr, int size) { float shrink_factor = 1.247330950103979; int gap = size, swapped = 1, swap, i; while ((gap > 1) || swapped) { if (gap > 1) gap = gap / shrink_factor; swapped = 0; i = 0; while ((gap + i) < size) { if (arr[i] - arr[i + gap] > 0) { swap = arr[i]; arr[i] = arr[i + gap]; arr[i + gap] = swap; swapped = 1; } ++i; } } }

Counting sort
Origem: Wikipdia, a enciclopdia livre.

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.
[editar]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 vectores auxiliares. O Counting Sort ordena exclusivamente nmeros inteiros pelo fato de seus valores servirem como ndices no vetor de contagem.
[editar]Cdigo

em C++

template<class T> std::vector<T> counting_sort( const std::vector<T> &op ) { if( op.empty() ) return std::vector<T>(); T min = *std::min_element( op.begin(), op.end() ); T max = *std::max_element( op.begin(), op.end() ); std::vector<int> contagem( max - min + 1, 0 ); for( std::vector<T>::const_iterator it = op.begin(); it != op.end(); ++it ); ++contagem[ *it - min ]; std::partial_sum( contagem.begin(), contagem.end(), contagem.begin() ); std::vector<T> ordenado( op.size() ); for( std::vector<T>::const_reverse_iterator it2 = op.rbegin(); it2 != op.rend(); ++it2 ) ordenado[ --contagem[ *it2 - min ] ] = *it2; return ordenado; }
[editar]Cdigo

em C

# include <stdio.h> # include <string.h> # include <stdlib.h>

# include <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 return 0; }

---

Key: %s\n",VectorSort[i].number,VectorSort[i].key);

Gnome sort
Origem: Wikipdia, a enciclopdia livre.

Algoritmo similiar 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. Caractersticas Complexidade de tempo: (n)

[editar]Implementaes [editar]Cdigo

em C

# include <stdio.h> # include <stdlib.h> # include <ctype.h> # include <string.h> # include <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]); }
[editar]Cdigo

em C++ verso 1

template<class T> void gnome_sort( std::vector<T> &lista ) { std::vector<T>::size_type i = 1; while( i < lista.size() ) { if( i == 0 || lista.at( i-1 ) <= lista.at( i ) ) { i++; } else { std::swap( lista[ i - 1 ], lista [ i ] ); --i; } } }
[editar]Cdigo

em C++ verso 2

template<class T> void gnome_sort( std::vector<T> &lista ) { std::vector<T>::iterator elem = lista.begin()+1; while( elem != lista.end() ) { if( elem == lista.begin() || *(elem-1) <= *elem ) { ++elem; } else { std::iter_swap( elem-1, elem ); --elem; } } }
[editar]Cdigo

em Java

import java.util.ArrayList; import java.util.Collection; import java.util.HashSet; import java.util.List; import java.util.Random; import java.util.Set; /** * Implementa e executa o algoritmo Gnome Sort * * @author Dielson Sales, Marcos Paulo J. Melo Silva * /

public class GnomeSort<E extends Comparable<? super E>> { /** * Ordena uma coleo de dados comparveis usando o Gnome Sort. * @param vector uma lista de dados comparveis * @return uma lista com os dados ordenados * / public Collection<E> sort(Collection<E> vector) { int i = 1; List<E> result = new ArrayList<E>(vector); while (i < result.size()) { if (i == 0 || result.get(i - 1).compareTo(result.get(i))<= 0) { i++; } else { E temp = result.get(i - 1); result.set(i - 1, result.get(i)); result.set(i, temp); i--; } } return result; } /** * Execuo do algoritmo de ordenao Gnome Sort. * / public static void main(String[] args) { GnomeSort<Integer> gnomeSort = new GnomeSort<Integer>(); final int size = 50; final Random random = new Random(); List<Integer> list = new ArrayList<Integer>(size); for (int i = 0; i < size; i++) { list.add(random.nextInt()); } // Lista com os dados j ordenados. Set<Integer> sortedList = new HashSet<Integer>(gnomeSort.sort(list)); } } /** * Exemplo de cdigo em Java * Autores: Marcos Paulo J. de Melo Silva e Dielson Sales de Carvalho;

* Instituio: Universidade Federal de Alagoas (UFAL); * /


[editar]Cdigo

em Java

/* * Autor: Felipe da Silva Travassos * Graduando em Cincia da Computao - UFCG */ public static Integer[] gnomeSort(Integer[] array){ int pivout = 0; int aux; while(pivout<(array.length-1)){ if(array[pivout]>array[pivout+1]){ aux = array[pivout]; array[pivout] = array[pivout+1]; array[pivout+1] = aux; if(pivout>0){ pivout-=2; } } pivout++; } return array; }

Heapsort
Origem: Wikipdia, a enciclopdia livre.

O algoritmo heapsort um algoritmo de ordenao generalista, e faz parte da famlia de algoritmos de ordenao por seleo. Foi desenvolvido em 1964 porRobert W. Floyd e J.W.J. Williams.
[editar]Definio

Tem um desempenho em tempo de execuo muito bom em conjuntos ordenados aleatoriamente, tem um uso de memria bem comportado e o seu desempenho em pior cenrio praticamente igual ao desempenho em cenrio mdio. Alguns algoritmos de ordenao rpidos tm desempenhos espectacularmente ruins no pior cenrio, quer em tempo de execuo, quer no uso da memria. O Heapsort trabalha no lugar e o tempo de execuo em pior cenrio para ordenar n elementos de O (n lg n). L-se logaritmo (ou log) de "n" na base 2. Para valores de n, razoavelmente grande, o termo lg n quase constante, de modo que o tempo de ordenao quase linear com o nmero de itens a ordenar.
[editar]Caractersticas

Comparaes no pior caso: 2n log2n + O(n) o mesmo que 2n lgn + O(n) Trocas no pior caso: n log2n + O(n) o mesmo que n lgn + O(n) Melhor e pior caso: O(n log2n) o mesmo que O(n lgn)

[editar]Funcionamento

O heapsort utiliza uma estrutura de dados chamada heap, para ordenar os elementos a medida que os insere na estrutura. Assim, ao final das inseres, os elementos podem ser sucessivamente removidos da raiz da heap, na ordem desejada, lembrando-se sempre de manter a propriedade de max-heap. A heap pode ser representada como uma rvore (uma rvore binria com propriedades especiais[2]) ou como um vetor. Para uma ordenao crescente, deve ser construdo uma heap mnima (o menor elemento fica na raiz). Para uma ordenao decrescente, deve ser construdo uma heap mxima (o maior elemento fica na raiz).
[editar]Implementaes [editar]Cdigo

em C

void heapsort(tipo a[], int n) { int i = n/2, pai, filho; tipo t; for (;;) { if (i > 0) { i--; t = a[i]; } else { n--; if (n == 0) return; t = a[n]; a[n] = a[0]; } pai = i; filho = i*2 + 1; while (filho < n) { if ((filho + 1 < n) filho++; if (a[filho] > t) { a[pai] = a[filho]; pai = filho; filho = pai*2 + 1; } else break; } a[pai] = t; } } && (a[filho + 1] > a[filho]))

[editar]Cdigo

em C++

template<class T> void heap_sort( std::vector<T> &lista ) { int tam = static_cast<int>( lista.size() ), i; for( i = tam/2 - 1; i >= 0; --i ) { maxHeapify(lista, i , tam ); } std::vector<T>::reverse_iterator elem; for( elem = lista.rbegin(); elem != lista.rend(); elem++ ) { std::iter_swap( elem, lista.begin() ); maxHeapify( lista, 0, --tam ); } } template<class T> void maxHeapify( std::vector<T> &lista, const int pos, const int n ) { int max = 2 * pos + 1; if( max < n ) { if( (max+1) < n && lista.at(max) < lista.at(max+1) ) { ++max; } if( lista.at(max) > lista.at(pos) ) { std::swap( lista[max], lista[pos] ); maxHeapify( lista, max, n ); } } }
[editar]Cdigo

em Java

public static void heapSort(int[] v) { buildMaxHeap(v); int n = v.length; for (int i = v.length - 1; i > 0; i--) { swap(v, i , 0); maxHeapify(v, 0, --n); } } private static void buildMaxHeap(int[] v) { for (int i = v.length/2 - 1; i >= 0; i--)

maxHeapify(v, i , v. length ); } private static void maxHeapify(int[] v, int pos, int n) { int maxi; int l = 2 * pos + 1; int right = 2 * pos + 2; if ( (l < n) && (v[l] > v[pos]) ) { maxi = l; } else { maxi = pos; } if (right < n && v[right] > v[maxi]) { maxi = right; } if (maxi != pos) { swap(v, pos, maxi); maxHeapify(v, maxi, n); } } public static void swap ( int[ ] v, int j, int aposJ ) { int aux = v [ j ]; v [ j ] = v [ aposJ ]; v [ aposJ ] = aux; }
[editar]Cdigo

em Java (5.0)

public static <T extends Comparable<? super T>> void heapSort(T[] v) { buildMaxHeap(v); int n = v.length; for (int i = v.length - 1; i > 0; i--) { swap(v, i, 0); maxHeapify(v, 0, --n); } } private static <T extends Comparable<? super T>> void buildMaxHeap(T v[]) { for (int i = v.length / 2 - 1; i >= 0; i--) maxHeapify(v, i, v.length); } private static <T extends Comparable<? super T>> void maxHeapify(T[] v, int pos, int n) { int max = 2 * pos + 1, right = max + 1; if (max < n) { if (right < n && v[max].compareTo(v[right]) < 0) max = right;

if (v[max].compareTo(v[pos]) > 0) { swap(v, max, pos); maxHeapify(v, max, n); } } } public static void swap(Object[] v, int j, int aposJ) { Object aux = v[j]; v[j] = v[aposJ]; v[aposJ] = aux; }

Insertion sort
Origem: Wikipdia, a enciclopdia livre.

Insertion sort, ou ordenao por insero, um simples algoritmo de ordenao, eficiente quando aplicado a um pequeno nmero de elementos. Em termos gerais, ele percorre um vetor de elementos da esquerda para a direita e medida que avana vai deixando os elementos mais esquerda ordenados. O algoritmo de insero funciona da mesma maneira com que muitas pessoas ordenam cartas em um jogo de baralho como o pquer.[1]

[editar]Caractersticas

Menor nmero de trocas e comparaes entre os algoritmos de ordenao O(n) quando o vetor est ordenado. Pior caso O(n)

[editar]Implementaes [editar]Java public static void insertionSort(int[] array) { for (int i = 1; i < array.length; i++) { int a = array[i]; for (int j = i - 1; j >= 0 && array[j] > a; j--) { array[j + 1] = array[j]; array[j] = a; } } }

[editar]C
void insertionSort(int V[], int tam) { int i, j, aux; for(i = 1; i < tam; i++){ j = i; while((V[j] < V[j - 1])&&(j!=0)) { aux = V[j]; V[j] = V[j - 1]; V[j - 1] = aux; j--; } } }

[editar]C++
void Inserction(int n, int vetor[]){ int j,i,key; for(j = 1; j < n; j++){ key = vetor[j]; i = j - 1; while(i >= 0 && vetor[i] > key){ vetor[i + 1] = vetor[i]; i = i - 1; } vetor[i + 1] = key; } }

Merge sort
Origem: Wikipdia, a enciclopdia livre.

O merge sort, ou ordenao por mistura, um exemplo de algoritmo de ordenao do tipo dividir-para-conquistar. Sua ideia bsica consiste em Dividir(o problema em vrios sub-problemas e resolver esses sub-problemas atravs da recursividade) e Conquistar(aps todos os sub-problemas terem sido resolvidos ocorre a conquista que a unio das resolues dos sub-problemas).Como o algoritmo do Merge Sort usa a recursividade em alguns problemas esta tcnica no muito eficiente devido ao alto consumo de memria e tempo de execuo. Os trs passos teis dos algoritmos dividir-para-conquistar, ou divide and conquer, que se aplicam ao merge sort so: 1. Dividir: Dividir os dados em subsequncias pequenas; 2. Conquistar: Classificar as duas metades recursivamente aplicando omerge sort;

3. Combinar: Juntar as duas metades em um nico conjunto j classificado.


[editar]Caractersticas

Complexidade de tempo: (n log2 n) Complexidade de espao: (n) possvel implementar o merge sort utilizando somente um vetor auxiliar ao longo de toda a execuo, tornando assim a complexidade de espao adicional igual a (n log n).

possvel tambm implementar o algoritmo com espao adicional (1) Algoritmo Criado por Von Neumann em 1945.

[editar]Desvantagens

Implementao complexa Ideia complexa Utiliza funes recursivas

[editar]Implementaes [editar]C

void merge(int vec[], int vecSize) { int mid; int i, j, k; int* tmp; tmp = (int*) malloc(vecSize * sizeof(int)); if (tmp == NULL) { exit(1); } mid = vecSize / 2; i = 0; j = mid; k = 0; while (i < mid && j < vecSize) { if (vec[i] < vec[j]) { tmp[k] = vec[i]; ++i; } else { tmp[k] = vec[j]; ++j; } ++k; } if (i == mid) { while (j < vecSize) { tmp[k] = vec[j]; ++j; ++k;

} } else { while (i < mid) { tmp[k] = vec[i]; ++i; ++k; } } for (i = 0; i < vecSize; ++i) { vec[i] = tmp[i]; } free(tmp); } void mergeSort(int vec[], int vecSize) { int mid; if (vecSize > 1) { mid = vecSize / 2; mergeSort(vec, mid); mergeSort(vec + mid, vecSize - mid); merge(vec, vecSize); } }
[editar]Cdigo

em C++

#include <algorithm> #include <iostream> #include <vector> std::vector<int> merge_sort(const std::vector<int> &data) { if (data.size() <= 1) { return data; } int middle = data.size() / 2; std::vector<int> left(data.begin(), data.begin()+middle); std::vector<int> right(data.begin()+middle, data.end()); left = merge_sort(left); right = merge_sort(right); std::vector<int> result(data.size()); std::merge(left.begin(), left.end(), right.begin(), right.end(), result.begin()); return result; }

Quicksort
Origem: Wikipdia, a enciclopdia livre.

O algoritmo Quicksort um mtodo de ordenao muito rpido e eficiente, inventado por C.A.R. Hoare em 1960[1], quando visitou a Universidade de Moscovocomo estudante. Naquela poca, Hoare trabalhou em um projeto de traduo de mquina para o National Physical Laboratory. Ele criou o 'Quicksort ao tentar traduzir um dicionrio de ingls para russo, ordenando as palavras, tendo como objetivo reduzir o problema original em subproblemas que possam ser resolvidos mais facil e rapidamente. Foi publicado em 1962 aps uma srie de refinamentos.[2] O Quicksort um algoritmo de ordenao por comparao no-estvel. O Quicksort adota a estratgia de diviso e conquista. A estratgia consiste em rearranjar as chaves de modo que as chaves "menores" precedam as chaves "maiores". Em seguida o Quicksort ordena as duas sublistas de chaves menores e maiores recursivamente at que a lista completa se encontre ordenada. 1. Escolha um elemento da lista, denominado piv; 2. Rearranje a lista de forma que todos os elementos anteriores ao piv sejam menores que ele, e todos os elementos posteriores ao piv sejam maiores que ele. Ao fim do processo o piv estar em sua posio final e haver duas sublistas no ordenadas. Essa operao denominada partio; 3. Recursivamente ordene a sublista dos elementos menores e a sublista dos elementos maiores; A base da recurso so as listas de tamanho zero ou um, que esto sempre ordenadas. O processo finito, pois a cada iterao pelo menos um elemento posto em sua posio final e no ser mais manipulado na iterao seguinte.
[editar]Complexidade
[3]

Os passos so:

Complexidade de tempo: (n lg2 n) no melhor caso e caso mdio e (n2) no pior caso; Complexidade de espao: (lg2 n) no melhor caso e no caso mdio e (lg2 n) no pior caso. R. Sedgewick desenvolveu uma verso do Quicksort com partio recurso de cauda que tem complexidade (n2) no pior caso.

[editar]Implementaes [editar]C++

#include <algorithm> #include <iterator> #include <functional> using namespace std; template <typename T> void sort(T begin, T end) { if (begin != end) { T middle = partition (begin, end, bind2nd(less<iterator_traits<T>::value_type>(), *begin)); sort (begin, middle); sort (max(begin + 1, middle), end); } }
[editar]C

void swap(int* a, int* b) { int tmp;

tmp = *a; *a = *b; *b = tmp; } int partition(int vec[], int left, int right) { int i, j; i = left; for (j = left + 1; j <= right; ++j) { if (vec[j] < vec[left]) { ++i; swap(&vec[i], &vec[j]); } } swap(&vec[left], &vec[i]); return i; } void quickSort(int vec[], int left, int right) { int r; if (right > left) { r = partition(vec, left, right); quickSort(vec, left, r - 1); quickSort(vec, r + 1, right); } } Implementao quicksort testado com ate 1000000 de elementos para dados crescente, decrescente e aleatrio void swap(int *a, int i, int j) { int t = a[i]; a[i] = a[j]; a[j] = t; } int partition(int *a, int left,int right,int pivot) { int pos, i; swap(a, pivot, right); pos = left; for(i = left; i < right; i++) { if (a[i] < a[right]) { swap(a, i, pos); pos++; } } swap(a, right, pos); return pos; }

void quick(int *a, int left, int right) { if (left < right) { int pivot = (left+right)/2; int pos = partition(a,left,right,pivot); quick(a,left,pos-1); quick(a,pos+1,right); } } Implementaao usando 'fat pivot': void sort(int array[], int begin, int end) { int pivot = array[begin]; int i = begin + 1, j = end, k = end; int t; while (i < j) { if (array[i] < pivot) i++; else if (array[i] > pivot) { j--; k--; t = array[i]; array[i] = array[j]; array[j] = array[k]; array[k] = t; } else { j--; swap(array[i], array[j]); } } i--; swap(array[begin], array[i]); if (i - begin > 1) sort(array, begin, i); if (end - k } Lembrando que quando voc for chamar a funo recursiva ter que chamar a mesma da seguinte forma ordenar_quicksort_nome(0,n-1). O 0(zero) serve para o incio receber a posio zero do vetor e o fim ser o tamanho do vetor 1. void ordenar_quicksort_nome(int ini, int fim) { int i = ini, f = fim; char pivo[50]; strcpy(pivo,vetor[(ini+fim)/2]); if (i<=f) { while (strcmpi(vetor[i],pivo)<0) i++; while (strcmpi(vetor[f],pivo)>0) f--; if (i<=f) { strcpy (aux_char,vetor[i]); strcpy (vetor[i],vetor[f]); strcpy (vetor[f],aux_char); > 1) sort(array, k, end);

i++; f--; } } if (f>ini) ordenar_quicksort_nome(ini,f); if (i<fim) ordenar_quicksort_nome(i,fim); }


[editar]JAVA

public static void quick_sort(int []v,int ini, int fim) { int meio; if (ini < fim) { meio = partition(v, ini, fim); quick_sort(v, ini, meio); quick_sort(v, meio + 1, fim); } } public static int partition(int []v, int ini, int fim) { int pivo, topo, i; pivo = v[ini]; topo = ini; for (i = ini + 1; i <= fim; i++) { if (v[i] < pivo) { v[topo] = v[i]; v[i] = v[topo + 1]; topo++; } } v[topo] = pivo; return topo; }
[editar]JAVA

public static void quickSort(int[] v, int inicio, int fim){ if(inicio<fim){ int pivo=inicio, i=fim, vPivo=v[pivo]; while(pivo<i){ if(vPivo>v[i]){ v[pivo]=v[i]; pivo=i; i=inicio+1; while(pivo>i){ if(vPivo<v[i]){ v[pivo]=v[i]; pivo=i; i=fim; break; }else i++; } } else i--; }

v[pivo]=vPivo; quicksort(v, inicio, pivo-1); quicksort(v, pivo+1, fim); } }

Comparao com outros algoritmos de ordenao


Quicksort uma verso optimizada de uma rvore binria ordenada. Em vez de introduzir itens sequencialmente numa rvore explicita, o Quicksort organiza-os correntemente na rvore onde est implcito, fazendo-o com chamadas recursivas mesma. O algoritmo faz exactamente as mesmas comparaes, mas com uma ordem diferente. O algoritmo que mais se familiariza com o Quicksort o Heapsort. Para o pior caso neste algoritmo temos Mas, o Heapsort em mdia trata-se de uma algoritmo mais lento que o Quicksort, embora tenha sido muito debatido essa afirmao. No Quicksort permanece o caso do pior caso, excepo quando se trata de usar a variante Intro sort, que muda para Heapsort quando um pior caso detectado. Caso se saiba partida que ser necessrio o uso do heapsort aconselhvel us-lo directamente, do que usar o introsort e depois chamar o heapsort, torna mais rpido o algoritmo. O Quicksort tambm compete com o Mergesort, outro algoritmo de ordenao recursiva, tendo este o benefcio de ter como pior caso . Mergesort, ao contrrio do Quicksort e do Heapsort, estvel e pode facilmente ser adptado para .

operar em listas encadeadas e em listas bastantes grandes alojadas num tipo de acesso lento a mdia como um NetworkAttached Storage ou num disco. Embora o Quicksort possa ser operado em listas encadeadas, por vezes escolhendo um mau piv sem acesso aleatrio. A maior desvantagem do Mergesort que quando opera em arrays, requer o melhor caso, considerando que o Quicksort com um particionamento espacial e com recurso utiliza apenas espao. Bucket sort com dois buckets muito parecido ao Quicksort (quase idntico), o piv neste caso garantidamente o valor do meio do vector. de espao para de

Selection sort
Origem: Wikipdia, a enciclopdia livre.

O selection sort (do ingls, ordenao por seleo) um algoritmo de ordenao baseado em se passar sempre o menor valor do vetor para a primeira posio (ou o maior dependendo da ordem requerida), depois o de segundo menor valor para a segunda posio, e assim feito sucessivamente com os (n-1) elementos restantes, at os ltimos dois elementos. == Complexidade == Muito Complexo O algoritmo possui complexidade complexidades
[editar]Implementaes [editar]C

enquanto que, por exemplo, os algoritmos Heapsort e Mergesort possuem

void selection_sort(int num[], int tam) { int i, j, min; for (i = 0; i < (tam-1); i++)

{ min = i; for (j = (i+1); j < tam; j++) { if(num[j] < num[min]) { min = j; } } if (i != min) { int swap = num[i]; num[i] = num[min]; num[min] = swap; } } } Cdigo da ordenao SelectionSort com strings void ordenar_selecao_nome() { int i,j,n; for(i=0; i<n-1; i++) { for(j=i+1; j<n; j++) { if(strcmp(vetor[i], vetor[j])>0) { strcpy(aux_char, vetor[i]); strcpy(vetor[i], vetor[j]); strcpy(vetor[j], aux_char); } } }
[editar]Cdigo

em C++

template<class T> void selection_sort( std::vector<T> &lista ) { for( std::vector<T>::iterator it = lista.begin(); it != lista.end()-1; ++it ) { std::iter_swap( it, std::min_element( it, lista.end() ) ); } }
[editar]Cdigo

em Java

public static void SelectionSort(int[] v) { int index_min; int aux; for (int i = 0; i < v.length; i++) { index_min = i; for (int j = i + 1; j < v.length; j++) { if (v[j] < v[index_min]) { index_min = j; } } if (index_min != i) { aux = v[index_min]; v[index_min] = v[i]; v[i] = aux; } }

Shell sort
Origem: Wikipdia, a enciclopdia livre.

Criado por Donald Shell em 1959,[1] publicado pela Universidade de Cincinnati, Shell sort o mais eficiente algoritmo de classificao dentre os de complexidade quadrtica. um refinamento do mtodo de insero direta.[2] O algoritmo difere do mtodo de insero direta pelo fato de no lugar de considerar o array a ser ordenado como um nico segmento, ele considera vrios segmentos sendo aplicado o mtodo de insero direta em cada um deles.[3] Basicamente o algoritmo passa vrias vezes pela lista dividindo o grupo maior em menores. Nos grupos menores aplicado o mtodo
[editar]Implementaes [editar]Cdigo

do algoritmo

em Java

public static void shellSort(Integer[] nums) { int n = nums.length; int h = n / 2; int c, j; while (h > 0) { for (int i = h; i < n; i++) { c = nums[i]; j = i; while (j >= h && nums[j - h] > c) { nums[j] = nums[j - h]; j = j - h; } nums[j] = c; } h = h / 2; } }
[editar]Cdigo

em C++

void ShellSort( apvector <int> &num) { int i, temp, flag = 1, numLength = num.length( ); int d = numLength; while( flag || (d > 1)) { flag = 0; d = (d+1) / 2; for (i = 0; i < (numLength - d); i++) { if (num[i + d] > num[i]) { temp = num[i + d]; num[i + d] = num[i]; num[i] = temp; flag = 1; } } } return; } // tells swap has occurred // swap positions i+d and i // boolean flag (true when not equal to 0) // reset flag to 0 to check for future swaps

[editar]Cdigo

em C

void shellSort(int * vet, int size) { int i , j , value; int gap = 1; do { gap = 3*gap+1; } while(gap < size); do { gap /= 3; for(i = gap; i < size; i++) { value =vet[i]; j = i - gap; while (j >= 0 && value < vet[j]) { vet [j + gap] =vet[j]; j -= gap; } vet [j + gap] = value; } } while ( gap > 1); }
[editar]Exemplo

de execuo

Execuo: Dado o vetor de entrada: 12, 43, 1, 6, 56, 23, 52, 9 12, 43, 1, 6, 56, 23, 52, 9 12, 43, 1, 6, 56, 23, 52, 9 1, 43, 12, 6, 56, 23, 52, 9 1, 6, 12, 23, 56, 43, 52, 9 1, 6, 12, 23, 52, 43, 56, 9 1, 6, 12, 23, 52, 9, 56, 43 1, 6, 12, 9, 52, 23, 56, 43 1, 6, 9, 12, 52, 23, 56, 43 1, 6, 9, 12, 23, 52, 56, 43 1, 6, 9, 12, 23, 52, 43, 56 1, 6, 9, 12, 23, 43, 52, 56 Em negrito esto os nmeros trocados na atual iterao. Aps as seguintes trocas acima, obtemos o vetor ordenado: 1, 6, 9, 12, 23, 43, 52, 56.
[editar]Concluso

A ordenao Shell utiliza a quebra sucessiva da sequncia a ser ordenada e implementa a ordenao por insero na sequncia obtida. Por ser um mtodo de complexidade O(n^2 ) no aconselhvel a sua implementao para sequncias grandes, mas possui uma boa eficincia para as pequenas e medianas.