Você está na página 1de 37

8

1. INTRODUÇÃO

Algoritmo de ordenação em ciência da computação é um algoritmo que coloca os


elementos de uma dada sequência em certa ordem em outras palavras, efetua sua
ordenação completa ou parcial, as ordens mais usadas são a numérica. Existem várias
razões para se ordenar uma sequência, uma delas é a possibilidade se acessar seus
dados de modo mais eficiente.

Um tipo de algoritmo bastante usado na resolução de problemas computacionais é os


algoritmos de ordenação, que servem para ordenar ou organizar uma lista de números
ou palavras de acordo com a sua necessidade, as linguagens de programação já
possuem métodos de ordenação. Ordenação é o ato de se colocar os elementos de
uma sequência de informações, ou dados, em uma ordem predefinida.

Um algoritmo é o fluxograma, uma representação visual que utiliza símbolos que são
figuras geométricas, cada uma com sua função especificam, mostra o fluxo do
algoritmo e também elimina as várias interpretações que a descrição narrativa permitia
sobre um algoritmo. Existe a linguagem algoritma (Portugol) que é a que mais se
aproxima da estrutura de uma linguagem estruturada.

Os mais populares algoritmos de ordenação são: Insertion Sort, Selection Sort, Bubble
Sort, Comb Sort, Merge Sort.
9

2. Objetivo do Trabalho

Este trabalho tem como objetivo mostrar que o algoritmo é um esquema de


resolução de um problema, pode ser implementado com qualquer sequência de valores
ou objetos que tenham uma lógica infinita, por exemplo, a língua portuguesa, a
linguagem Pascal, a linguagem C, uma sequência numérica, ou seja, qualquer coisa
que possa fornecer uma sequência lógica.

A vantagem dessa forma de representação é que qualquer um pode fazê-la sem ter
conhecimentos avançados.

A desvantagem é que não há um padrão, cada pessoa pode escrever como quiser.

A Classificação ou ordenação de dados tem assumido grandes proporções no âmbito


do processamento de informações, devido a sua importância na análise de
desempenho e de ser utilizado como processo intermediário em diversas aplicações.
10

3. Estrutura de Dados

Na Ciência da Computação, uma estrutura de dados é um modo particular de


armazenamento e organização de dados em um computador de modo que possam ser
usados eficientemente.

Estruturas de dados e algoritmos são temas fundamentais da ciência da computação,


sendo utilizados nas mais diversas áreas do conhecimento e com os mais diferentes
propósitos de aplicação. As estruturas de dados são chamadas tipos de dados
compostos que se dividem em homogêneos (vetores e matrizes) e heterogêneos
(registros). As estruturas homogêneas são conjuntos de dados formados pelo mesmo
tipo de dado primitivo. As estruturas heterogêneas são conjuntos de dados formados
por tipos de dados primitivos diferentes.

Figura 1: Árvore Binária

4. Algoritmos de Ordenação
11

Na Ciência da Computação, os algoritmos de ordenação são o algoritmo que


coloca os elementos de uma dada sequência em certa ordem, em outras palavras
efetua sua ordenação completa ou parcial.

O objetivo da ordenação é facilitar a recuperação dos dados de uma lista.

4.1 Definição de Algoritmos

O Algoritmo é um esquema de resolução de um problema, pode ser


implementado com qualquer sequência de valores ou objetos que tenham uma lógica
infinita ( Por exemplo, a língua portuguesa, a linguagem Pascoal, a linguagem C, uma
sequência numérica, um conjunto de objetos tais como lápis e borracha), ou seja,
qualquer coisa que possa fornecer uma sequência lógica.

Podemos ilustrar um algoritmo pelo exemplo de uma receita culinária, embora muitos
algoritmos sejam mais complexos. Um Algoritmo mostra passo a passo os
procedimentos necessários para resolução de um problema.

5. Linguagem Algoritmo (Pseudocódigo ou Portugol)


12

Essa forma consiste na definição de uma pseudolinguagem de programação, cujos


comandos são em português, mas que já lembram um pouco a estrutura de uma
linguagem de programação estruturada, ou seja, a pseudolinguagem se assemelha
muito ao modo como os programas são escritos. Isso vai permitir que os algoritmos
fossem traduzidos, quase que diretamente, para uma linguagem de programação.

Algoritmo “Calcular Média” em linguagem algoritma

Algoritmo “CalcularMedia” var n1,n2,n3,media :real; inicio leia(n1,n2,n3); media←


(n1+n2+n3)/3; se media>=6 então escreva(“Parabéns você foi aprovado”); senão
escreva(“Infelizmente você ficou de exame”); Fim se fimalgoritmo.

Figura 3:Algoritmo

6. Métodos de Ordenação
13

Ordenar corresponde ao processo de reorganizar um conjunto de objetos em


ordem ascendente ou descendente. O objetivo principal da ordenação é facilitar a
recuperação posterior de itens do conjunto ordenado

typedef struct

{
int key ; //Campo chave

}TItem ; Não precisa


Tabela 1: TItem

Para testarmos cada algoritmo precisamos gerar vetores de diversos tamanhos:


ascendente em ordem alfabética. Foram usadas as seguintes estruturas e funções para
representar e gerar os vetores para testes dos algoritmos:

List<List<String>> copiaVetorpalavrasEmbaralhadas = new List<List<string>>();


List<List<String>> vetorpalavrasEmbaralhadas = new List<List<string>>();

vetorpalavrasEmbaralhadas.Add(new palavrasAleatoria.Add("M");
List<string>()); palavrasAleatoria.Add("A");
palavrasAleatoria.Add("B");
vetorpalavrasEmbaralhadas.Add(new palavrasAleatoria.Add("O");
List<string>()); palavrasAleatoria.Add("C");
palavrasAleatoria.Add("S");
vetorpalavrasEmbaralhadas.Add(new palavrasAleatoria.Add("D");
List<string>()); palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E");
vetorpalavrasEmbaralhadas.Add(new palavrasAleatoria.Add("X");
List<string>()); palavrasAleatoria.Add("G");
List<String> palavrasAleatoria = palavrasAleatoria.Add("F");
new List<String>(); palavrasAleatoria.Add("Z");
14

palavrasAleatoria.Add("I"); palavrasAleatoria.Add("N");
palavrasAleatoria.Add("Q"); palavrasAleatoria.Add("U");
palavrasAleatoria.Add("W"); palavrasAleatoria.Add("J");
palavrasAleatoria.Add("L"); palavrasAleatoria.Add("P");
palavrasAleatoria.Add("H"); palavrasAleatoria.Add("Y");
palavrasAleatoria.Add("N"); palavrasAleatoria.Add("R");
palavrasAleatoria.Add("U"); palavrasAleatoria.Add("T");
palavrasAleatoria.Add("J"); palavrasAleatoria.Add("V");
palavrasAleatoria.Add("P"); palavrasAleatoria.Add("M");
palavrasAleatoria.Add("Y"); palavrasAleatoria.Add("A");
palavrasAleatoria.Add("R"); palavrasAleatoria.Add("B");
palavrasAleatoria.Add("T"); palavrasAleatoria.Add("O");
palavrasAleatoria.Add("V"); palavrasAleatoria.Add("C");
palavrasAleatoria.Add("M"); palavrasAleatoria.Add("S");
palavrasAleatoria.Add("A"); palavrasAleatoria.Add("D");
palavrasAleatoria.Add("B"); palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("O"); palavrasAleatoria.Add("E");
palavrasAleatoria.Add("C"); palavrasAleatoria.Add("X");
palavrasAleatoria.Add("S"); palavrasAleatoria.Add("G");
palavrasAleatoria.Add("D"); palavrasAleatoria.Add("F");
palavrasAleatoria.Add("Z"); palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E"); palavrasAleatoria.Add("I");
palavrasAleatoria.Add("X"); palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("G"); palavrasAleatoria.Add("W");
palavrasAleatoria.Add("F"); palavrasAleatoria.Add("L");
palavrasAleatoria.Add("Z"); palavrasAleatoria.Add("H");
palavrasAleatoria.Add("I"); palavrasAleatoria.Add("N");
palavrasAleatoria.Add("Q"); palavrasAleatoria.Add("U");
palavrasAleatoria.Add("W"); palavrasAleatoria.Add("J");
palavrasAleatoria.Add("L"); palavrasAleatoria.Add("P");
palavrasAleatoria.Add("H"); palavrasAleatoria.Add("Y");
15

palavrasAleatoria.Add("R"); palavrasAleatoria.Add("G");
palavrasAleatoria.Add("T"); palavrasAleatoria.Add("F");
palavrasAleatoria.Add("V"); palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("M"); palavrasAleatoria.Add("I");
palavrasAleatoria.Add("A"); palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("B"); palavrasAleatoria.Add("W");
palavrasAleatoria.Add("O"); palavrasAleatoria.Add("L");
palavrasAleatoria.Add("C"); palavrasAleatoria.Add("H");
palavrasAleatoria.Add("S"); palavrasAleatoria.Add("Giovanni");
palavrasAleatoria.Add("D"); palavrasAleatoria.Add("Ricardo");
palavrasAleatoria.Add("Z"); palavrasAleatoria.Add("Gustavo");
palavrasAleatoria.Add("E"); palavrasAleatoria.Add("Eduardo");
palavrasAleatoria.Add("X");

int teste = 100;


for (int indice = 0; indice < 4; indice++)
{

while (vetorpalavrasEmbaralhadas[indice].Count < teste)


{
vetorpalavrasEmbaralhadas[indice].AddRange(palavrasAleatoria);

}
teste *= 10;
}

Tabela 2: Tarray
16

6.1 Ordenação Interna:

São os métodos que não necessitam de uma memória secundária para o


processo, a ordenação é feita na memória principal do computador.

6.2 Ordenação Externa:

Quando o arquivo a ser ordenado não cabe na memória principal, tem de ser
armazenado em fita ou disco.

A principal diferença entre os dois grupos é que no método de ordenação interna


qualquer registro pode ser acessado diretamente, enquanto no método externo é
necessário fazer o acesso em blocos.

Figura 4:Redes
17

7. Métodos de Ordenação Interna

Quando vamos escolher um algoritmo de ordenação, devemos olhar um aspecto


importante, quanto tempo será gasto durante a execução. Para algoritmos de
ordenação interna, as medidas de complexidade relevantes contam o número de
movimentações de itens do arquivo e o número de comparações entre chaves.

Outra medida que pesa na escolha é a quantidade de memória extra utilizada


pelo algoritmo. Métodos que realizam a permutação dos elementos no próprio vetor são
chamados IN SITU, esses métodos são os preferidos. Os métodos que necessitam de
memória extra para armazenar outra cópia dos itens possuem menor importância.

Os métodos de ordenação interna são classificados em dois subgrupos:

Métodos Simples:

 BubbleSort

 InsertSort

Métodos Eficientes:

 ShellSort

 QuickSort

BubbleSort

Bubble sort é um dos algoritmos mais simples, porém um dos algoritmos menos
eficientes. Nesse algoritmo o elemento que se encontra na posição x será comparado
com o da posição x + 1, ou seja, o elemento que se encontra na posição dois será
comparado com o da posição três. Caso o elemento da posição dois for maior que o da
posição três, eles trocam de lugar e assim sucessivamente. Por causa dessa forma de
execução, o vetor terá que ser percorrido quantas vezes que for necessária, tornando o
algoritmo ineficiente para listas muito grandes.
18

7.1 Análise do algoritmo

O BubbleSort é um método de simples implementação, porem a sua eficiência é


a menor entre os métodos de ordenação interna. Admite contudo vários melhoramentos
e é também uma boa base para a construção de métodos mais elaborados.

Vantagens:

* Fácil implementação;

* Algoritmo estável

Desvantagens:

* O fato de arquivo já estar ordenado não ajuda em nada;

* Ordem de complexidade quadrática.


19

7.2 InsertSort

O método de ordenação por Inserção Direta é o mais rápido entre os outros


métodos considerados básicos, ele é um algoritmo simples e eficiente quando aplicado
em pequenas listas. Neste algoritmo a lista é percorrida da esquerda para a direita, à
medida que avança vai deixando os elementos mais à esquerda ordenados.O algoritmo
funciona da mesma forma que as pessoas usam para ordenar cartas em um jogo de
baralho como o pôquer.

Tabela 4: ilustração do funcionamento do algoritmo InsertSort

7.2.1 Análise do algoritmo

Vantagens:

* Fácil implementação;

* Algoritmo estável;

* O vetor já ordenado favorece a ordenação

Desvantagens:

* Número grande de movimentações;

* Ordem de complexidade quadrática.


20

7.3 ShellSort

ShellSort baseia-se em se passar sempre o menor valor para a primeira posição,


depois o segundo menor valor para a segunda posição e assim sucessivamente, até os
dois últimos elementos.

Neste algoritmo será escolhido um número a partir do primeiro, este número


escolhido é comparado com os números a partir da sua direita, quando encontrado um
número menor, o número escolhido ocupa a posição do menor número encontrado.
Este número encontrado será o próximo número escolhido, caso não for encontrado
nenhum número menor que este escolhido, ele é colocado na posição do primeiro
número escolhido, e o próximo número à sua direita vai ser o escolhido para fazer as
comparações. É repetido esse processo até que a lista esteja ordenada.

7.3.1 Análise do algoritmo

O ShellSort é um método muito simples, ele apresenta um comportamento


fantástico quanto ao número de movimentos de registros, cujo tempo de execução é
linear, esta particularidade é dificilmente encontrada em outros algoritmos de
ordenação.
21

Vantagens:

* Fácil implementação;

* Pequeno número de movimentações;

* Interessante para arquivos pequenos

Desvantagens:

* O fato de arquivo já estar ordenado não influencia em nada;

* Ordem de complexidade quadrática;

* Algoritmo não estável

7.4 QuickSort

Este é o algoritmo com mais eficácia na ordenação por comparação. Neste


algoritmo será escolhido um numero chamado de pivô, a partir daí será ele organizara
uma lista para que todos os números que venham antes a ele sejam menores, e todos
os que venham depois sejam maiores que ele. Ao termino desse processo o número
pivô já está em sua posição final.
22

7.4.1 Análise do Algoritmo

Este é o método que consideramos o mais eficiente e é muito recomendável para


arquivos grandes. Quanto mais o vetor estiver desordenado, maior será sua vantagem
em relação aos outros métodos. A escolhe correta do pivô é essencial para a garantia
de eficiência do algoritmo.

Vantagens:
23

* Extremamente de uma pequena pilha como memória extra,

* Complexidade n log n.

Desvantagens:

* Implementação difícil;

* Não é estável.
24

8. Metodologia dos Testes

Os algoritmos de ordenação foram escritos na linguagem C#. O sofware utilizado


para edição e compilação do código foi o Microsoft Visaul Studio Express 2012.

Para realização dos testes em lotes foram utilizadas palavras armazenadas em


um List<string>, que contem as informações para os testes: Método de ser realizado,
tamanho do vetor, performance de ordenação.

8.1 Resultados

Foram testados os quatros métodos de ordenação, para método foi testado um


tamanho diferente de vetor (100, 1000, 10000, 100000) e para cada tamanho um tipo
diferente (Ordenado Crescente em ordem alfabética). Para o tipo Aleatório o teste foi
realizado para 4 vetores diferentes mediante os tamanhos, assim o resultado aqui
apresentado é a média dos valores.

BubbleSort

InsertSort

QuickSort

8.2 Os resultados em função do tempo

Vetor Ordenado em Ordem Crescente e Alfabética

100 1000 10000 100000

0,000050 0,004822 0,483164 48,373736

Tabela 8: Ordem Crescente

9. CÓDIGO FONTE
25

Classe ordenação

using System;
using System.Collections.Generic;
using System.Text;

namespace APSOrdenacaoDeDados
{
class Ordenacao
{
//Metodos que seream sobrescritos em cada classe especializada
public virtual List<String> ordenar(List<String> lista) { return null; }
public virtual String nomeDaOrdenacao() { return ""; }

}
}

Classe BubbleSort

using System;
using System.Collections.Generic;
using System.Text;
using System.Diagnostics;

namespace APSOrdenacaoDeDados
{
class BubleSort : Ordenacao
{

//Metodo que realiza a ordenação com o algoritmo BubbleSort


public override List<String> ordenar(List<String> lista)
26

{
for (int i = 1; i < lista.Count; i++)
{
for (int j = 0; j < lista.Count - 1; j++)
{
if (lista[j].CompareTo(lista[j + 1]) == 1)
{
string temp = lista[j];
lista[j] = lista[j + 1];
lista[j + 1] = temp;

return lista;

}
//Aqui ele retorna o nome da Ordenação
public override string nomeDaOrdenacao()
{
return "BubleSort";
}

}
}
Classe InsertSort

using System;
using System.Collections.Generic;
27

using System.Linq;
using System.Text;

namespace APSOrdenacaoDeDados
{
class InsertSort : Ordenacao
{
//Aui retorna o nome da ordenação
public override string nomeDaOrdenacao()
{
return "InsertSort";
}

//Aqui ele recebe a lista desordenada e chama o metodo responsavel pela


//ordenação com a lista como parametro
public override List<string> ordenar(List<string> lista)
{
return insertSort(lista);
}
//Aqui é o metodo responsavel pela ordenação
public List<String> insertSort(List<String> lista)
{
int j;
string escolhido;
for (int i = 1; i < lista.Count; i++)
{
escolhido = lista[i];
j = i;

while ((j > 0) && (lista[j - 1].CompareTo(escolhido) > 0))


{
28

lista[j] = lista[j - 1];


j = j - 1;
}
lista[j] = escolhido;
}
return lista;
}

}
}

Classe QuickSort

using System;
using System.Collections.Generic;
using System.Text;

namespace APSOrdenacaoDeDados
{
class QuickSort : Ordenacao
{
//Aqui ele sofre uma sobre carga
public List<String> organizar(List<String> vetor)
{
return organizar(vetor, 0, vetor.Count - 1);
}

private List<String> organizar(List<String> vetor, int inicio, int fim)


{
if (inicio < fim)
{
int posicaoPivo = Separar(vetor, inicio, fim);
29

organizar(vetor, inicio, posicaoPivo - 1);


organizar(vetor, posicaoPivo + 1, fim);
}

return vetor;
}

//aqui ele inicia o processo de divisão do vetor e o reposicionamento das partes


private static int Separar(List<String> vetor, int inicio, int fim)
{
String pivo = vetor[inicio];
int i = inicio + 1, f = fim;
while (i <= f)
{
if (vetor[i].CompareTo(pivo) <= 0)
i++;
else if (pivo.CompareTo(vetor[f]) < 0)
f--;
else
{
String troca = vetor[i];
vetor[i] = vetor[f];
vetor[f] = troca;
i++;
f--;
}

}
vetor[inicio] = vetor[f];
vetor[f] = pivo;
return f;
30

//Aqui inicia o processo de ordenação com chamada do metodo organizar


public override List<string> ordenar(List<string> lista)
{

return organizar(lista);

}
//aqui devolve o nome do stilo do algoritmo
public override string nomeDaOrdenacao()
{
return "QuickSort";
}
}
}

Classe Programam

using System;
using System.Collections.Generic;
using System.Text;
using System.Timers;

namespace APSOrdenacaoDeDados
{
//Essa é a classe teste
class Program
{
31

static void Main(string[] args)


{
//Aqui é declarado e instanciado as classes especializadas do tipo Ordenação
List<Ordenacao> ordenacao = new List<Ordenacao>();
ordenacao.Add(new BubleSort());
ordenacao.Add(new QuickSort());
ordenacao.Add(new InsertSort());

int escolhaDoMenu =0;//serve para escolher o menu

//Aqui é criado dois conjuntos de lista pois uma será copia da outra
//afim de não ser necessario reescrevela apenas trabalhar com a copia depois
//de ordenado rertona a forma anterior.
List<List<String>> copiaVetorpalavrasEmbaralhadas = new List<List<string>>();
List<List<String>> vetorpalavrasEmbaralhadas = new List<List<string>>();

//aqui é instanciado as listas internas pois seram nelas


//armazenadas as palavras dividida pelo tamanho que segue pela posição
// intes 100 posição 0
// intes 1000 posição 1
// intes 10000 posição 2
// intes 100000 posção 3
vetorpalavrasEmbaralhadas.Add(new List<string>());
vetorpalavrasEmbaralhadas.Add(new List<string>());
vetorpalavrasEmbaralhadas.Add(new List<string>());
vetorpalavrasEmbaralhadas.Add(new List<string>());

//Aqui é declaradoo e instañciado e preencido esse vetor como base com 100
itens
32

List<String> palavrasAleatoria = new List<String>();


palavrasAleatoria.Add("M");
palavrasAleatoria.Add("A");
palavrasAleatoria.Add("B");
palavrasAleatoria.Add("O");
palavrasAleatoria.Add("C");
palavrasAleatoria.Add("S");
palavrasAleatoria.Add("D");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E");
palavrasAleatoria.Add("X");
palavrasAleatoria.Add("G");
palavrasAleatoria.Add("F");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("I");
palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("W");
palavrasAleatoria.Add("L");
palavrasAleatoria.Add("H");
palavrasAleatoria.Add("N");
palavrasAleatoria.Add("U");
palavrasAleatoria.Add("J");
palavrasAleatoria.Add("P");
palavrasAleatoria.Add("Y");
palavrasAleatoria.Add("R");
palavrasAleatoria.Add("T");
palavrasAleatoria.Add("V");
palavrasAleatoria.Add("M");
palavrasAleatoria.Add("A");
palavrasAleatoria.Add("B");
palavrasAleatoria.Add("O");
33

palavrasAleatoria.Add("C");
palavrasAleatoria.Add("S");
palavrasAleatoria.Add("D");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E");
palavrasAleatoria.Add("X");
palavrasAleatoria.Add("G");
palavrasAleatoria.Add("F");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("I");
palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("W");
palavrasAleatoria.Add("L");
palavrasAleatoria.Add("H");
palavrasAleatoria.Add("N");
palavrasAleatoria.Add("U");
palavrasAleatoria.Add("J");
palavrasAleatoria.Add("P");
palavrasAleatoria.Add("Y");
palavrasAleatoria.Add("R");
palavrasAleatoria.Add("T");
palavrasAleatoria.Add("V");
palavrasAleatoria.Add("M");
palavrasAleatoria.Add("A");
palavrasAleatoria.Add("B");
palavrasAleatoria.Add("O");
palavrasAleatoria.Add("C");
palavrasAleatoria.Add("S");
palavrasAleatoria.Add("D");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E");
34

palavrasAleatoria.Add("X");
palavrasAleatoria.Add("G");
palavrasAleatoria.Add("F");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("I");
palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("W");
palavrasAleatoria.Add("L");
palavrasAleatoria.Add("H");
palavrasAleatoria.Add("N");
palavrasAleatoria.Add("U");
palavrasAleatoria.Add("J");
palavrasAleatoria.Add("P");
palavrasAleatoria.Add("Y");
palavrasAleatoria.Add("R");
palavrasAleatoria.Add("T");
palavrasAleatoria.Add("V");
palavrasAleatoria.Add("M");
palavrasAleatoria.Add("A");
palavrasAleatoria.Add("B");
palavrasAleatoria.Add("O");
palavrasAleatoria.Add("C");
palavrasAleatoria.Add("S");
palavrasAleatoria.Add("D");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("E");
palavrasAleatoria.Add("X");
palavrasAleatoria.Add("G");
palavrasAleatoria.Add("F");
palavrasAleatoria.Add("Z");
palavrasAleatoria.Add("I");
35

palavrasAleatoria.Add("Q");
palavrasAleatoria.Add("W");
palavrasAleatoria.Add("L");
palavrasAleatoria.Add("H");
palavrasAleatoria.Add("Giovane");
palavrasAleatoria.Add("Ricardo");
palavrasAleatoria.Add("Gustavo");
palavrasAleatoria.Add("Eduardo");

//aqui é feito o preenchimento das listas com as quantidades certas


//de palavras cada posição com a sua respsctiva quantidade.
int teste = 100;
for (int indice = 0; indice < 4; indice++)
{

while (vetorpalavrasEmbaralhadas[indice].Count < teste)


{
vetorpalavrasEmbaralhadas[indice].AddRange(palavrasAleatoria);

}
teste *= 10;
}

do//aqui inicia a primeira tentativa de compilar o sistema


{
//nesse ponto é feita a copia da lista inicial
copiaVetorpalavrasEmbaralhadas.AddRange(vetorpalavrasEmbaralhadas);

Console.WriteLine("Vetor antes da Ordenação");


36

Console.WriteLine("vetor palavrasAleatoria {0}: {1}", 0,


copiaVetorpalavrasEmbaralhadas[0].Count);
Console.WriteLine("vetor palavrasAleatoria {0}: {1}", 1,
copiaVetorpalavrasEmbaralhadas[1].Count);
Console.WriteLine("vetor palavrasAleatoria {0}: {1}", 2,
copiaVetorpalavrasEmbaralhadas[2].Count);
Console.WriteLine("vetor palavrasAleatoria {0}: {1}", 3,
copiaVetorpalavrasEmbaralhadas[3].Count);

Console.WriteLine();

try
{//aqui é montado o menu do sistema
Console.WriteLine("Escolha o menu precionando o numero
correspondente");

Console.WriteLine("0 - Ordenação bubbleSort");


Console.WriteLine("1 - Ordenação quickSort");
Console.WriteLine("2 - Ordenação insertSort");
Console.WriteLine("9 - Para sair");
Console.Write("Menu: ");
escolhaDoMenu = int.Parse(Console.ReadLine());
if (escolhaDoMenu == 0 || escolhaDoMenu == 1 || escolhaDoMenu == 2)
{
Console.Write("\n");
Console.Write("\n");
Console.WriteLine("Procensando Ordenação em " +
ordenacao[escolhaDoMenu].nomeDaOrdenacao() + " ...");
Console.Write("\n");
int quantDeItensNoVetor = 100;
for (int i = 0; i < 4; i++)
37

{
//************************Inicia a contagem de tempo****************
DateTime inicioT = DateTime.Now;
//Aqui é chamado o processo de ordenação
List<String> listaOrdenada =
ordenacao[escolhaDoMenu].ordenar(copiaVetorpalavrasEmbaralhadas[i]);
DateTime fimT = DateTime.Now;
//************************Termina a contagem de tempo****************
Console.WriteLine();
Console.WriteLine("Com "+quantDeItensNoVetor.ToString() +"
intes levou: {0} milessegundos ",fimT.Subtract(inicioT));
Console.WriteLine();
quantDeItensNoVetor *= 10;
}

Console.WriteLine();

//Console.WriteLine("Tempo gasto para ordenar:


hora:minuto:segundo.mile segundo " + fimT.Subtract(inicioT).TotalMilliseconds
/*ordenacao[escolhaDoMenu].retornaTempo()*/);
Console.WriteLine("Precione qualquer tecla...");
//Console.WriteLine("Precione qualquer tecla...");
Console.ReadKey();
Console.WriteLine();
}

else if (escolhaDoMenu == 9) { Console.WriteLine("Obrigado pela


preferência"); }
else { Console.WriteLine("Escolha a opção do menu"); }
}
catch (Exception erro)
38

{
Console.WriteLine("Precione um numero dentro do escopo "+erro);
}

//como já foi ordenado essa lista ela é apagada e sobresquita


//assim que repete esses passos.
copiaVetorpalavrasEmbaralhadas.Clear();

} while (escolhaDoMenu != 9);

}
}
39

10. Conclusão

Este trabalho possibilitou um aprofundamento sobre os algoritmos de ordenação


bem como a análise do número de atribuições, comparações e tempo de execução de
forma bem eficiente. Pelos testes executados pode-se concluir que:
Vale a pena inserir a verificação de ordenação (houve troca) no algoritmo BubbleSort;

Não vale a pena usar o algoritmo InsertSort com elemento sentinela;

Vale a pena inserir uma verificação (Min == i) para evitar a troca, no método SelectSort;

O QuickSort é o algoritmo mais eficiente para ordenar vetores de grandes dimensões.

Vale a pena usar os algoritmos simples até vetores de 70 elementos, acima desse valor
deve-se usar os algoritmos eficientes.As dificuldades encontradas foram devido ao fato
haver várias alterações no código, implementação do InserSort com cursores e de gerar
os gráficos com eficiência. A combinação entre a tecnologia disponibilizada pelo
processamento paralelo e a eficiência dos algoritmos de ordenação produz algoritmos
paralelos de ordenação comanto poder de computação.
40

11. Bibliografia

http://www.devmedia.com.br/algoritmos-de-ordenacao-analise-e-comparacao

www.google.com.br/search?
q=DESENVOLVIMENTO+DE+SISTEMA+PARA+ANÁLISE+DE+PERFORMANCE+DE+
ALGORITMOS+DE+ORDENAÇÃO+DE+DADOS”&hl=pt-
BR&source=lnms&sa=X&ei=DQt5U-
6mGpeQqAbR54HgCA&ved=0CAcQ_AUoAA&biw=1366&bih=639&dpr=1

www.devmedia.com.br/algoritmos-de-ordenacao-analise-e-comparacao/28261

http://pt.wikipedia.org/wiki/Estrutura_de_dados

http://pt.wikipedia.org/wiki/Bubble_sort
41
42
43