INSTITUTO VIANNA JÚNIOR FACULDADES INTEGRADAS VIANNA JÚNIOR ANÁLISE DA COMPLEXIDADE DE ALGORITMOS DE ORDENAÇÃO

Transcrição

1 INSTITUTO VIANNA JÚNIOR FACULDADES INTEGRADAS VIANNA JÚNIOR ANÁLISE DA COMPLEXIDADE DE ALGORITMOS DE ORDENAÇÃO Lúcia Helena de Magalhães 1 Mônica de Lourdes Souza Batista 2 Teresinha Moreira Magalhães 3 Thiago José de Souza Batista 4 1. Introdução O problema da ordenação é fundamental na computação, e como nos métodos de pesquisa a eficiência da busca sempre é melhor quando trabalhamos com conjuntos ordenados. Para que os dados sejam mais facilmente manipulados, é necessário que estes utilizem algum critério de ordenação. Seria impossível achar o número de telefone de alguém se a lista telefônica estivesse desordenada. Ordenar significa rearranjar um conjunto de objetos em uma ordem ascendente ou descendente. O objetivo principal da ordenação é facilitar a recuperação posterior de itens do conjunto ordenado. Existem vários algoritmos que permitem a realização da ordenação dos dados. O objetivo deste artigo é estudar alguns destes algoritmos e analisar a complexidade dos mesmos. 1 Lúcia Helena de Magalhães, Mestre em Sistemas Computacionais Computação de Auto-Desempenho pela Universidade Federal do Rio de Janeiro, Pós Graduada em Desenvolvimento de Aplicações para Web pelo Centro de Ensino Superior, Pós Graduada em Matemática e Estatística pela Universidade Federal de Lavras e Professora do Curso de Sistemas de Informação da Faculdade de Ciências Gerenciais de Santos Dumont, professora da Faculdade do Sudeste Mineiro e professora do Curso de Desenvolvimento Web das Faculdades Integradas do Instituto Vianna Júnior. lmagalhaes@viannajr.edu.br 2 Mônica de Lourdes Souza Batista, Mestranda em Computação Visual pela Universidade Federal Fluminense, Bacharel em Sistemas de Informação pela Faculdade Metodista Granbery. Programadora responsável pela Internet do Instituto Vianna Júnior. monicasouzabatista@gmail.com 3 Teresinha Moreira de Magalhães, Doutoranda em Sistemas Computacionais Computação de Auto- Desempenho pela Universidade Federal do Rio de Janeiro, Mestre em Engenharia de Produção pela Universidade Federal de Santa Catarina, Pós Graduada em Redes de Computadores pelo Centro de Ensino Superior de Juiz de Fora e Pós Graduada em Matemática e Estatística pela Universidade Federal de Lavras. Professora do Curso de Desenvolvimento Web das Faculdades Integradas Vianna Júnior, coordenadora do Ensino a distância e departamento de Informática da FIVJ. tmagalhaes@viannajr.edu.br 4 Thiago José de Souza Batista, Bacharelando em Sistemas de Informação pela Faculdade Metodista Granbery. shogumjf@gmail.com

2 Este trabalho é subdividido em introdução, desenvolvimento com as sessões de 2 a 5 e a conclusão. Na seção 2 é apresentado o BubleSort; na seção 3, o SelectSort; na seção 4, o MergeSort; e na seção 5 é mostrado o QuickSort. Por fim, são destacadas as considerações finais do trabalho e as referências bibliográficas utilizadas. Para cada algoritmo foi realizado um estudo da complexidade do mesmo. 2. BubleSort O BubleSort é um método de ordenação por troca. Ele é o mais simples, embora não muito eficaz. O princípio deste método consiste em varrer a lista várias vezes e trocar cada elemento corrente (posição i) com o posterior (posição i + 1), caso Ci > C i + 1, onde C e Ci+1 são respectivamente as chaves dos registros (DROZDEK, 2002). O melhor caso ocorre quando todos os elementos do vetor já estão ordenados. O pior caso acontece quando o vetor se encontra inversamente ordenado. Para qualquer caso a complexidade é O(n 2 ) (KNUTH, 1998). O Programa 1 mostra o código fonte do BubleSort. Algoritmo escrito na Linguagem C. #include <stdio.h> #include <stdlib.h> #include <conio.h> #include<iostream> using namespace std; #define TAMANHO_DO_ARRAY 5 int i, j, aux, pass; bool trocou; int v[tamanho_do_array]; main() printf("informe no maximo %d numeros\n", TAMANHO_DO_ARRAY); for (i = 0; i < TAMANHO_DO_ARRAY; i++) printf("informe um numero inteiro positivo para a %d posicao: ", i+1); scanf("%d",&v[i]); for (pass = 0; pass < TAMANHO_DO_ARRAY - 1; pass++) trocou = false; for (j = 0; j < TAMANHO_DO_ARRAY - (pass + 1) ; j++) if (v[j] > v[j+1]) aux = v[j]; v[j] = v[j+1]; v[j+1] = aux;

3 trocou = true; printf("os numeros ordenados sao: "); printf("\n"); for (i = 0; i < TAMANHO_DO_ARRAY; i++) printf("%d\n",v[i]); getch(); Programa 1: Código fonte do BubleSort 3. SelectSort O princípio básico do SelectSort consiste em se escolher o menor valor da chave de um vetor e trocar este com o primeiro registro da sequência. O processo é repetido trocando-se o menor valor da chave dos n-1 registros (desconta-se o primeiro) com o segundo registro, troca-se o menor valor da chave dos n-2 registro (desconta-se o primeiro e o segundo registros) com o terceiro registro e assim sucessivamente. O código do SelectSort é descrito abaixo (ZIVIANI, 1999). O Programa 2 ilustra o código fonte do SelectSort. #include <stdio.h> #include <stdlib.h> #include <conio.h> #include<iostream> using namespace std; #define TAMANHO_DO_ARRAY 5 int i, j, aux, minimo; int v[tamanho_do_array]; main() printf("informe no maximo %d numeros\n", TAMANHO_DO_ARRAY); //o usuario entra com os dados for (i = 0; i < TAMANHO_DO_ARRAY; i++) printf("informe um numero inteiro positivo para a %d posicao: ", i + 1); scanf("%d",&v[i]); //fim o usuario entra com os dados //select sort for (i = 0; i < TAMANHO_DO_ARRAY - 1; i++) minimo = i; for (j = i + 1; j < TAMANHO_DO_ARRAY ; j++) if (v[j] < v[minimo])

4 minimo = j; aux = v[minimo]; v[minimo] = v[i]; v[i] = aux; //fim select sort printf("os numeros ordenados sao: \n"); for (i = 0; i < TAMANHO_DO_ARRAY; i++) printf("%d\n",v[i]); getch(); Programa 2: Código fonte do SelectSort A análise da complexidade deste algoritmo é a seguinte: 1ª iteração: compara o 1º elemento com os n-1 demais: n-1 comparações. 2ª iteração: compara o 2º elemento com os n-2 demais: n-2 comparações. 3ª iteração: compara o 3º elemento com os n-3 demais: n-3 comparações. Número total de comparações C(n): (n-1) + (n-2) = (n2 - n)/2 = O(n2) Portanto, a complexidade desse algoritmo no pior caso, no caso médio e no melhor caso é a mesma: O(n²). 4. MergeSort O algoritmo MergeSort consiste em sortear n listas de tamanho 1. Estas listas são intercaladas, utilizando-se o procedimento Merge, em n/2 pares de listas, cada qual com tamanho 2 (se n é impar, então existirá uma lista com tamanho 1). Estas n/2 listas são intercaladas por pares gerando-se no final, como resultado, uma lista. De forma recursiva a lista é dividida em n/4 listas são intercaladas por pares gerando-se no final, como resultado, uma nova lista e assim por diante até se ter somente uma lista que está ordenada (KNUTH, 1998). O processo chave no MergeSort é fundir metades ordenadas de uma lista em uma lista ordenada. No entanto, essas metades precisam ser ordenadas primeiro, o que é realizado fundindo as metades já ordenadas dessas metades. Esse processo de dividir listas em duas metades pára quando a lista tem menos de dois elementos (DROZDEK, 2002). O algoritmo do MergeSort é ilustrado no seguinte código: #include <stdio.h> #include <stdlib.h>

5 #include <conio.h> #define TAMANHO_DO_ARRAY 5 int i, j, meio, k, inicio, fim; int a[tamanho_do_array]; int b[tamanho_do_array]; int mergesort(int e, int d); int merge(int e, int m, int d); int mergesort(int e, int d) if (e < d) meio = (e + d)/2; mergesort(e, meio); mergesort(meio + 1, d); merge(e, meio, d); int merge(int e, int m, int d) i = e; j = m + 1; k = e; while ((i<=m) && (j<=d)) if (a[i] < a[j]) b[k] = a[i]; k++; i++; else b[k] = a[j]; k++; j++; while (i <= m) b[k] = a[i]; k++; i++; while (j <= d) b[k] = a[j]; k++; j++; for (i = 0; i <= d; i++) a[i] = b[i];

6 int main(int argc, char *argv[]) printf("informe no maximo %d numeros\n", TAMANHO_DO_ARRAY); inicio = 0; fim = TAMANHO_DO_ARRAY - 1 ; //o usuario entra com os dados for (i = 0; i <= fim; i++) printf("informe um numero inteiro positivo para a %d posicao: ", i + 1); scanf("%d",&a[i]); //fim o usuario entra com os dados mergesort(inicio, fim); printf("os numeros ordenados sao: \n"); for (i = 0; i <= fim; i++) printf("%d\n", a[i]); getch(); Programa 3: Código fonte do MergeSort Segundo Drozdek (2002), o pior caso é quando o último elemento de uma metade precede somente o último elemento da outra metade, como por exemplo, [1,6,10,12] e [5,9,11,13]. Para uma lista de n elementos, o número de movimentos é calculado pela seguinte relação de recorrência: M(1) = 0 M(n) = 2M(n/2) + 2n M(n) pode ser calculado do seguinte modo: M(n) = 2(2M(n/4) + 2(2/n)) + 2n = 4M(n/4) + 4n = 4(2M(n/8) + 2(n/4) + 4n) = 8M(n/8) + 6n... = 2iM(n/2i) + 2in Escolher i = logn, de modo que n = 2i permite inferir que: M(n) = 2iM(n/2i) + 2in = nm(1) + 2nlogn = 2nlogn = O(nlogn). O número de comparações, no pior caso, é dado por uma relação similar:

7 C(1) = 0 C(n) = 2C(n/2) + n-1 Que também resulta em C(n), sendo O(nlogn). 5. QuickSort Este método é o mais eficaz de ordenação baseado em troca. O conceito básico deste algoritmo consiste em se dividir o conjunto original em dois subconjuntos separados por um elemento escolhido arbitrariamente, denominado de pivô. Para cada partição, escolhe-se o primeiro elemento da lista esquerda cuja chave seja maior que a chave do pivô, e escolhe-se o primeiro elemento da lista direita cuja chave seja menor que a chave do pivô. Os dois elementos são trocados. Este processo é repetido enquanto existir registros para serem trocados. Os subconjuntos são ordenados separadamente utilizando de forma recursiva o mesmo procedimento descrito anteriormente. Isto é, para cada subconjunto, escolhe-se arbitrariamente um elemento e, em seguida, ordena-se os dois conjuntos separadamente (ZIVIANI, 1999). O custo para percorrer o vetor comparando-se cada elemento com o pivô, é linear, ou seja, O(n). 5.1 Análise da escolha do pivô QuickSort ou Ordenação Rápida, é um método eficaz de ordenação baseado em troca. Para se resolver o problema da ordenação, a lista original é dividida em duas sublistas. A primeira contém elementos menores ou iguais a uma chave escolhida chamada de limite ou pivô. A segunda lista inclui elementos iguais ou menores que o pivô (ZIVIANI, 1999). As duas sublistas são ordenadas separadamente, mas, antes que isso seja feito, o processo de partição é repetido para ambas as sublistas. Como resultado, dois novos pivôs são escolhidos, um para cada sublista. Este processo de particionar é realizado até que haja somente listas de uma célula que precisem ser ordenadas. Dividir a tarefa de ordenar uma grande lista em duas tarefas mais simples e então dividir essas tarefas em tarefas ainda mais simples resulta em dados já ordenados, no processo de se preparar para ordenar (ZIVIANI, 1999). Para particionar uma lista, duas operações tem que ser realizadas: um pivô deve ser encontrado e a lista precisa ser varrida para colocar os elementos nas sublistas apropriadas. No entanto, escolher um bom pivô não é uma tarefa trivial. O ideal é que as sublistas devem ser aproximadamente do mesmo comprimento. Se uma matriz contém os números de 1 até 100 e 2 é escolhido como um limite, tem-se um desbalanceamento: a primeira sublista contém somente

8 um número depois do particionamento, enquanto a segunda tem 99 números (DROZDEK, 2002). Várias estratégias diferentes para selecionar um pivô foram desenvolvidas. Uma das mais simples consiste em escolher o primeiro elemento da lista. Essa abordagem pode ser suficiente para algumas aplicações. No entanto, como muitas listas a serem ordenadas já têm muitos elementos em suas próprias posições, uma abordagem mais cuidadosa é escolher o elemento alocado no meio da lista. Outra tarefa é varrer a matriz e dividir os elementos entre suas duas sublistas. O algoritmo que realiza esta tarefa não decide onde colocar um elemento igual ao pivô; ele somente diz que os elementos são colocados na primeira sublista caso sejam menores ou iguais ao pivô, e na segunda, caso sejam maiores ou iguais ao pivô. A razão é que a diferença entre os comprimentos das duas sublistas deve ser mínimo. Em conseqüência, os elementos iguais ao pivô devem ser divididos igualmente entre as duas submatrizes, para tornar essa diferença de tamanho mínima (DROZDEK, 2002). Existem vários métodos para se encontrar o pivô. Um método gera aleatoriamente um número entre o início e o final da lista. Esse número é utilizado como índice do pivô. Um outro método escolhe uma mediana dos três elementos da lista, dentre eles, o primeiro, o médio e o último (DROZDEK, 2002). 5.2 Complexidade do QuickSort Análise do Pior caso O Pior Caso ocorre quando o algoritmo de particionamento produz a cada chamada um subproblema de tamanho n-1 e outro de tamanho 1. Nesse contexto pode-se extrair a seguinte relação de recorrência: T(1) = O(1) T(n) = T(n-1) + O(n) Resolvendo esta relação de recorrência, acha-se a complexidade do QuickSort no pior caso, ou seja, O(n 2 ) Análise do Melhor Caso O Melhor Caso ocorre quando o particionamento divide o vetor a cada chamada em dois subproblemas de tamanhos aproximadamente iguais a n/2, que produz a seguinte relação de recorrência: T(1) = O(1)

9 T(n) = 2T(n/2) + O(n) Resolvendo esta relação de recorrência, acha-se a complexidade do QuickSort no melhor caso, ou seja, O(nlogn) Análise do Caso Médio Considere o código a seguir: void quicksort(v,a,b) if a>=b return else m = split(v,a,b) quicksort(v,a,m-1) quicksort(v,m+1,b) O efeito da execução de m=split(v,a,b) á alterar o vetor v[], definindo um índice m tal que todos os elementos da seção do vetor v[a..m-1] são menores ou iguais a v[m] e todos os elementos da seção do vetor v[m+1..b] são maiores que v[m]. Seja n = b - a + 1 o número de elementos a ordenar. Na execução de m=split(v,a,b) há n - 1 comparações envolvendo elementos do vetor. Pretende-se mostrar que o número de comparações c(n) é de ordem O(nlogn); mais precisamente que é sempre c(n) knlogn para uma constante k apropriada. Admite-se que os elementos do vetor são todos distintos e que todas as n! permutações de elementos são igualmente prováveis. Assim, o valor de m dado por m=split(v,a,b) tem a mesma probabilidade se ser a, de ser a + 1,... e de ser b; essa probabilidade é 1/n (relembra-se que n = b - a + 1). Abaixo tem-se recorrência que determina o valor médio do número de comparações:

10 É possível notar que para cada i 2 1, 2,..., n o valor c(i) ocorre 2 vezes na soma anterior; pode-se então escrever a recorrência da forma seguinte: Pré-teorema: A solução c(n) da recorrência é majorada por knlogn em que o valor de k é encontrado na demonstração. Caso base, n = 1: tem-se (da recorrência) c(1) = 0 k(1log1) para qualquer k > 0; analogamente se trata o caso n = 0. Passo de indução: supor que c(i) kilogi para todo o i com 0 i n-1. Abaixo é possível visualizar que c(n) k(n log n). onde α = 2k(-2 ln 2 + 1)/n tem valor negativo. O teorema fica então demonstrado se for n - 1 kn/2, pois fica então k(nlogn). Em particular podemos tomar k = 2 e enunciar a versão final do pré-teorema anterior. Conclui-se que o número de comparações efetuadas pelo quicksort é, no caso médio, majorado por 2nlogn. O Programa 4 mostra o código do QuickSort: #include <stdio.h> #include <stdlib.h> #define TAMANHO_DO_ARRAY 20

11 int partition(int e, int d); void quicksort(int e, int d); int a[tamanho_do_array]; void quicksort(int e, int d) int i; if (e < d) i = partition(e,d); quicksort(e, i - 1); quicksort(i + 1, d); int partition(int e, int d) int v, i, j, aux; v = a[d];//pivo -> pode ser qquer valor i = e - 1; j = d; do do i++; while ((a[i] < v) && (i < d)); do j--; while ((a[j] > v) && (j > 0)); aux = a[i]; a[i] = a[j]; a[j] = aux; while (j > i); a[j] = a[i]; a[i] = a[d]; a[d] = aux; return i; int main(int argc, char *argv[]) int i, pare; pare = a[0] = 0; printf("informe no maximo %d numeros\n", TAMANHO_DO_ARRAY); for (i = 1; i < TAMANHO_DO_ARRAY; i++)

12 if (!pare) printf("informe um numero inteiro positivo para a %d posicao: ", i); scanf("%d",&a[i]); else if (a[i] < 1) pare = 1; else a[0]++; a[i] = -1; quicksort(1, a[0]); printf("os numeros ordenados sao: \n"); if (a[0] > 0) else for (i = 1; i <= a[0]; i++) printf("%d ", a[i]); printf("\n"); printf("nenhum numero informado!\n"); Programa 4: Código fonte do QuickSort 6. Considerações finais Um problema fundamental da ciência da computação está na ordenação de uma lista de itens. Existem muitos algoritmos de ordenação para resolver este problema. Alguns algoritmos são simples e intuitivos, como por exemplo o BubleSort. Outros são extremamente complicados, como por exemplo o QuickSort. Esse artigo abordou diferentes algoritmos de ordenação de itens, além de estudar a complexidade de cada um deles. É importante lembrar que existem outros, tais como InsertionSort, HeapSort, ShellSort, RadixSort, etc. 6. Referências biliográficas DROZDEK, A. Estrutura de Dados e Algoritmos em C++. São Paulo: Pioneira Thomson Learning, 2002

13 KNUTH, D. Section 5.2.4: Sorting by Merging, The Art of Computer Programming. Addison-Wesley, Pag São Paulo: ZIVIANI, N. Projeto de Algoritmos com Implementação em Pascal e C. 4ª Ed. São Paulo: Pioneira, 1999