Algoritmos e Estruturas de Dados I

Algoritmos e Estruturas de Dados I
Projeto de Implementação
Comparação Empirica dos
Algoritmos de Ordenação
(Data de entrega 08/05)

Projeto proposto pelo
Prof. André Balan

Objetivo
● Realizar um estudo empírico do consumo de
tempo dos algoritmos de ordenação vistos em
classe.

● Pouco eficientes:
– BubbleSort
– InsertionSort
– SelectionSort
● Mais eficientes:
– QuickSort
– HeapSort
– MergeSort
Algoritmos

O Módulo de Ordenação
● Criar um “Módulo de Ordenação”
– Interface: ordenacao.h
– Implementação: ordenacao.c
● A interface será dada a seguir, e você não poderá
mudá-la
● Você deverá definir as funções declaradas na
interface no arquivo ordenacao.c (que deverá
incluir a interface, ou seja, deverá fazer
#include "ordenacao.h")

#ifndef _ORDENACAO_H
#define _ORDENACAO_H
Interface
void bubble_sort(int *v, int n);
void insertion_sort(int *v, int n);
void selection_sort(int *v, int n);
void quick_sort(int *v, int n);
void merge_sort(int *v, int n);
void heap_sort(int *v, int n);
#endif

Detalhes de Implementação
● Todas as funções recebem um vetor v de inteiros
(passado sob forma de ponteiro) e o número
n de elementos desse vetor.
● Em sala, definimos as funções quick_sort e
merge_sort recebendo três parâmetros como
(int *v, int p, int r).
● Para poder implementá-las do modo como foi
pedido, você poderá definir novas funções
dentro de ordenacao.c (que não serão visíveis
fora desse arquivo e que só poderão ser
chamadas de dentro de ordenacao.c).

Metodologia
● Após criar o Módulo de Ordenação, criar um
programa para realizar o estudo empírico dos
métodos de ordenação implementados.
● Cada algoritmo de ordenação deverá ser testado
com vetores de elementos do tipo int,
dos seguintes tamanhos:
● 10.000
● 30.000
● 90.000
● 270.000
● 810.000
● 2.430.000
● 7.290.000
● 21.870.000
● 65.610.000

Gerando vetores aleatórios
● Os vetores são compostos por números inteiros,
com distribuição uniforme, gerados com a
função rand() da biblioteca stdlib.h
– v[i] = rand();
– /* gera um inteiro entre 0 e 2.147.483.647 */
● Para cada tamanho de vetor, o programa deve
rodar cada método de ordenação com 6
sequências aleatórias diferentes:
● (6 algoritmos) x (9 tamanhos) x (6 sequências) =
324 ordenações

Garantindo comparação justa
● Atenção: em cada “rodada” de ordenações,
todos os algoritmos devem ordenar a mesma
sequência aleatória para que a comparação
seja justa.
● Como gerar a mesma sequência aleatória em
tempos diferentes?

Garantindo comparação justa
● Na verdade, os computadores geram números
pseudoaleatórios.
● Toda função que cria números pseudoaleatórios,
cria uma sequência de números a partir
de uma semente (seed).
● Se as sementes usadas para a geração de
duas seqüências são iguais, as seqüências
geradas serão iguais.

Gerando a mesma seqüência
● Asssim, para criarmos duas sequências pseudoaleatórias
idênticas em tempos diferentes,
basta definirmos a mesma semente (seed)
para as duas sequências:
// criamos uma sequência
srand(seed);
for (i = 0; i < n; i ++) v[i] = rand();
// criamos uma sequência idêntica à anterior
srand(seed);
for (i = 0; i < n; i ++) v[i] = rand();

Sementes para cada seqüência
● Neste trabalho, você deve criar 6 sequências
pseudoaleatórias. Para isso, você deverá utilizar
as seguintes seeds:
– seed[0] = 4
– seed[1] = 81
– seed[2] = 151
– seed[3] = 1601
– seed[4] = 2307
– seed[5] = 4207

Metodologia (cont.)
● Além disso, o programa também deve realizar
uma rodada de ordenações com uma sequência
de 50.000 itens ordenados inversamente.
● Atenção, o QuickSort pode falhar ao processar
grandes sequências: stack overflow!
● Para que o QuickSort não estoure a pilha de
execução, use o particiona aleatorizado!

Metodologia (cont.)
● Para cada ordenação o programa deve medir:
– o tempo total em milissegundos
● Cada par (método, tamanho) terá 6 medições
de tempo (uma para cada seqüência pseudoaleatória
daquele tamanho)

Medindo o tempo decorrido
● Como medir o tempo de uma ordenação?
// Não se esqueça de incluir a biblioteca time.h
#include
int inicio, final;
int tempo_ms;
start = (int) clock();
// chamada da função de ordenação
final = (int) clock();
tempo_ms = ((final - inicio) * 1000 / CLOCKS_PER_SEC);
printf("%d", tempo_ms);

Metodologia (cont.)
● Após desenvolver o programa, chegou a hora
de colocar pra rodar e ir dormir.
● Deixe apenas o seu programa rodar. Não faça
nada no computador enquanto o experimento
estiver rodando (não mexa nem o mouse).
● O programa deve lhe retornar todos os dados
necessários para você realizar o estudo empírico.

Resultados
● Com todos os dados obtidos, você deve elaborar
um relatório contendo
– gráficos que permitam uma comparação fácil e
rápida entre os métodos
– análise dos gráficos
● Em um único gráfico, coloque várias curvas
de tempo, uma para cada método. Cada ponto
das curvas de tempo, é uma média aritmética
de 6 medidas de tempo, uma para cada
sequência aleatória.

Resultados
● Muito provavelmente, os métodos ineficientes
irão desbalancear as comparações.
● Sendo assim, você deve decidir se estes métodos
devem ser colocados em gráficos separados.
● Você pode decidir também, um timeout para
cada experimento (vamos combinar 20 min)
para que não demore a vida inteira para rodar
o projeto todo.

Resultados
● Se algum método excedeu 20min quando ao
tentar ordenar um vetor de um certo tamanho,
você não precisa rodar o experimento com
outros vetores desse tamanho ou maiores!
● Para cada par (método, tamanho) que não foi
rodado por completo, estimar o quanto ele
demoraria para rodar e justificar sua estimativa.

Análise
● O relatório deve conter uma seção de análise,
onde você deve discutir os resultados obtidos
empíricamente com as análise de complexidade
dos algotirmos vistas em aula.
● Consulte a bibliografia indicada no site para
tirar suas dúvidas.
● Trabalho em duplas ou individual.

Entrega
Todo o código fonte e o relatório em pdf
(entregar no TIDIA até o dia 08/05)
● Turma do matutino: fazer em C
● Tidia matutino: BC1424-AED1-matutino
● Turma do noturno: fazer em C ou C++
● Tidia noturno: AED1-2012-1

Bom trabalho!