Algoritmos de ordenação

SOCIEDADE EDUCACIONAL DE SANTA CATARINAINSTITUTO SUPERIOR TUPYENGENHARIA DE COMPUTAÇÃO RELATÓRIO DE DESENVOLVIMENTO DE ALGORITMOS DE ORDENAÇÃO EM C#.NETAluno: Lorival Smolski ChapuisTurma: ECP-341Professor: Glauco Vinicius Scheffel Joinville, 9 de abril de 2011

Sumário1. Introdução ............................................................................................................................. 32. Ferramentas e métodos utilizados ........................................................................................ 43. Algoritmos de ordenação ...................................................................................................... 5 3.1. BubbleSort ..................................................................................................................... 6 3.2. SelectionSort ................................................................................................................. 9 3.3. InsertionSort................................................................................................................ 12 3.4. MergeSort ................................................................................................................... 15 3.5. QuickSort ..................................................................................................................... 214. Execução dos testes automatizados ................................................................................... 245. Estatísticas entre os algoritmos de ordenação ................................................................... 276. Conclusão ............................................................................................................................ 30

1. Introdução Este relatório tem como objetivo detalhar o desenvolvimento dos algoritmos deordenação bubblesort, selectionsort, insertionsort, mergesort e quicksort. Os algoritmos foram desenvolvidos em C# utilizando a IDE Visual Studio 2010, .NetFramework 4.0, testes automatizados e orientação a aspectos. A solução criada possui dois projetos. Um deles é responsável por implementar osalgoritmos de ordenação e o outro responsável apenas pelos testes. Ao apresentar cada algoritmo de ordenação, é resumido seu funcionamento edetalhado o código fonte em C#, que aparece logo em seguida, juntamente com oscódigos dos testes automatizados. Ao final foram feitas estatísticas de desempenho comparando os algoritmos,descritos acima, para ver o tempo de ordenação, de cada um, em um vetor de milposições. Todos os códigos fontes estão em formas de texto exceto por duas imagens, printsdos códigos. Isto acontece, pois foi utilizado um recurso chamado “region” quepermite separar e organizar melhor o código, podendo ocultar ou exibir trechos decódigos. Os prints foram tirados para mostrar o código desejado juntamente com osregions “fechados”, que serão “abertos” e explicados na sequência.

2. Ferramentas e métodos utilizados Para o desenvolvimento dos algoritmos foi utilizado o seguinte ambiente:  Microsoft Visual Studio 2010;  Microsoft .Net Framework 4.0 com a linguagem C#;  Testes automatizados;  Orientação a aspectos; Os testes automatizados foram de dois tipos unitários e integrados. Isto devido àcomplexidade de testar alguns métodos e de o autor não querer colocar mocks paranão complicar mais os programas. A programação orientada a aspectos – POA – é um paradigma de desenvolvimentoque possibilita implementar funcionalidades que se encontram espalhadas por todaaplicação (crosscutting concern) de forma encapsulada e modularizada. Dentro do .Net Framework um dos princípios do POA é chamado de extensionmethods que consiste em desenvolver um algoritmo separado de seu objeto de uso earmazená-lo junto aos demais métodos do Framework, para ser usado a qualquermomento de qualquer lugar da solução que utilize a biblioteca em questão. Um exemplo de extension method, seria criar um método chamado ToShortString()para conversão de um datetime (1/12/2999 00:00:00) para uma data curta(01/12/20999). Ao criar este método informamos que será aplicado ao tipo datetime,logo os objetos datetime terão mais um método (ToShortString()) podendo ser usadode qualquer parte da solução e a qualquer momento. Exemplo de uso do métodoacima: DateTime date = DateTime.Now; String shortDate = date.ToShortString(); Se não utilizar um extension method, o modo convencional seria criar um métodoque recebe-se como parâmetro um datetime e retorna-se uma string. Como é apenasum algoritmo de conversão, poderia estar em uma classe estática chamadaDateConvertionHelper. Veja um exemplo de uso: DateTime date = DateTime.Now; String shortDate = DateConvertionHelper.ToShortString(date); Usar um extension method torna muito mais simples a utilização final.

3. Algoritmos de ordenação Para não tornar o relatório longo e ser o mais objetivo possível, cada tópico dealgoritmo será dividido em 3 partes:  Objetivo;  Algoritmo;  Testes. Para mais informações sobre os testes, veja o item “4. Execução dos testesautomatizados”. Foi criada uma classe chamada SortingAlgorithms que contém os 6 algoritmos deordenação. O escopo desta classe está abaixo e o conteúdo dos “regions” estãodetalhados em cada algoritmo.

3.1. BubbleSortObjetivo: Percorrer o vetor diversas vezes e a cada passagem fazer flutuar para o finaldo vetor o item de maior valor. A cada passagem é analisado a quantidade de itens dovetor menos um, pois o último já estará ordenado.Algoritmo:#region BubbleSortpublic static void BubbleSort(this IList<int> list){ int lastListPosition = list.Count - 1; bool hasChanged = true; while (hasChanged) { hasChanged = false; for (int i = 0; i < lastListPosition; i++) { if (list[i] > list[i + 1]) { var aux = list[i]; list[i] = list[i + 1]; list[i + 1] = aux; hasChanged = true; } } lastListPosition--; }}#endregion

Testes:using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class BubbleSortTestar : AbstractTester { [TestMethod] public void BubbleSortTestar_SortTwoItems() { //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void BubbleSortTestar_SortFiveItemsNeedTwoSteps() { //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void BubbleSortTestar_SortFiveItemsNeedThreeSteps() { //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void BubbleSortTestar_SortTenItems() { //-- Arrange

int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void BubbleSortTestar_SortTenItemsWithRepetedValues() { //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void BubbleSortTestar_SortOneHumdredItems() { //-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.BubbleSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual); } }}

3.2. SelectionSortObjetivo: Percorrer o vetor diversas vezes e a cada passagem trazer para a primeiraposição do vetor o item de menor valor. A cada passagem é analisado a quantidade deitens do vetor menos um, pois o primeiro já estará ordenado. A grande diferença doselectionsort para o bubblesort é que o bubble faz varias trocas a cada passagem e aseleção procura o menor valor e faz apenas uma troca no final da passagem.Algoritmo:#region SelectionSortpublic static void SelectionSort(this IList<int> list){ int lowestValuePosition = 0; for (int lastPosition = 0; lastPosition < list.Count; lastPosition++) { lowestValuePosition = lastPosition; for (int currentPosition = lastPosition; currentPosition < list.Count; currentPosition++) { if (list[currentPosition] < list[lowestValuePosition]) lowestValuePosition = currentPosition; } if (lowestValuePosition > lastPosition) { var aux = list[lastPosition]; list[lastPosition] = list[lowestValuePosition]; list[lowestValuePosition] = aux; } }}#endregion

Testes:using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class SelectionSortTester : AbstractTester { [TestMethod] public void SelectionSortTester_SortTwoItems() { //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void SelectionSortTester_SortFiveItems() { //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void SelectionSortTester_SortFiveItemsInOtherOrder() { //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void SelectionSortTester_SortTenItems() { //-- Arrange

int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void SelectionSortTester_SortTenItemsWithRepetedValues() { //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void SelectionSortTester_SortOneHumdredItems() { //-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.SelectionSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual); } }}

3.3. InsertionSortObjetivo: Percorrer o vetor da esquerda para a direita e à medida que avança vaideixando os elementos mais a esquerda ordenados. A cada passagem vai abrindoespaço para o item corrente e procurando, mais a esquerda qual é o lugar daqueleitem. Ao encontrar empurra todos os itens para a direita e insere o item selecionadono seu respectivo local.Algoritmo:#region InsertionSortpublic static void InsertionSort(this IList<int> list){ int valueWillBeInserted, lastPosition; for (int currentPosition = 1; currentPosition < list.Count; currentPosition++) { valueWillBeInserted = list[currentPosition]; lastPosition = currentPosition - 1; while (lastPosition >= 0 && list[lastPosition] > valueWillBeInserted) { list[lastPosition + 1] = list[lastPosition]; lastPosition--; } list[lastPosition + 1] = valueWillBeInserted; }}#endregion

Testes:using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class InsertionSortTester : AbstractTester { [TestMethod] public void InsertionSortTester_SortTwoItems() { //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void InsertionSortTester_SortFiveItems() { //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void InsertionSortTester_SortFiveItemsInOtherOrder() { //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void InsertionSortTester_SortTenItems() { //-- Arrange

int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void InsertionSortTester_SortTenItemsWithRepetedValues() { //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void InsertionSortTester_SortOneHumdredItems() { //-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.InsertionSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual); } }}

3.4. MergeSortObjetivo: Criar uma sequência ordenada baseada em outras duas também ordenadas.Para isto é necessário dividir a sequência original até chegar a um limite ordenável porum insertionSort (100 itens neste exemplo) ou até sobrarem pares para ordenar.Depois vai agrupando todas as sequências divididas até formar a sequência ordenada.Modo com InsertionSort e sem InsertionSort Foi desenvolvido dois métodos de chamada. Um para mergeSort comInsertionSort e outro sem InsertionSort. Ambos utilizam o mesmo algoritmo paraordenação com a diferença de um parâmetro que informa se irá usar o algoritmoInsertionSort quando chegar nos 100 itens ou não.

Algoritmo:#region Private Methodsprivate static IList<int> ExecuteMergeSort(IList<int> list, bool sortWithInsertionSort){ if (sortWithInsertionSort) { if (list.Count <= 100) { list.InsertionSort(); return list; } } else if (list.Count <= 1) return list; int midlePosition = list.Count / 2; IList<int> leftSide = new List<int>(); IList<int> rightSide = new List<int>(); for (int i = 0; i < midlePosition; i++) leftSide.Add(list[i]); for (int i = midlePosition; i < list.Count; i++) rightSide.Add(list[i]); return ExecuteMergeSort(ExecuteMergeSort(leftSide, sortWithInsertionSort),ExecuteMergeSort(rightSide, sortWithInsertionSort));}private static IList<int> ExecuteMergeSort(IList<int> left, IList<int> right){ IList<int> listToBeReturned = new List<int>(); while (left.Count > 0 && right.Count > 0) if (left[0] > right[0]) { listToBeReturned.Add(right[0]); right.RemoveAt(0); } else { listToBeReturned.Add(left[0]); left.RemoveAt(0); } for (int i = 0; i < left.Count; i++) listToBeReturned.Add(left[i]); for (int i = 0; i < right.Count; i++) listToBeReturned.Add(right[i]); return listToBeReturned;}#endregion

Testes:using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class MergeTester : AbstractTester { #region WithOutInsertionSort [TestMethod] public void MergeTester_SortTwoItems() { //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void MergeTester_SortFiveItems() { //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void MergeTester_SortFiveItemsInOtherOrder() { //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void MergeTester_SortTenItems() {

//-- Arrange int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortTenItemsWithRepetedValues(){ //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortOneHumdredItems(){ //-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.MergeSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual);}#endregion#region WithInsertionSort[TestMethod]public void MergeTester_SortTwoItems_WithInsertionSort(){ //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortFiveItems_WithInsertionSort()

{ //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortFiveItemsInOtherOrder_WithInsertionSort(){ //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortTenItems_WithInsertionSort(){ //-- Arrange int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortTenItemsWithRepetedValues_WithInsertionSort(){ //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(expected, actual);}[TestMethod]public void MergeTester_SortOneHumdredItems_WithInsertionSort(){

//-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.MergeSortWithInsertionSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual); } #endregion }}

3.5. QuickSortObjetivo: Ordena o vetor dividindo-o recursivamente, através de um pivô, colocandoos itens menores que o pivô de um lado e maiores do outro. Ao final os itens estarãoordenados. Este é o algoritmo mais rápido e eficiente para ordenação para vetoresgrandes.Algoritmo:#region QuickSortpublic static void QuickSort(this IList<int> list){ Sort(list, 0, list.Count - 1);}#region Private Methodsprivate static void Sort(IList<int> list, int startPosition, int endPosition){ if (startPosition < endPosition) { int pivotPosition = Partition(list, startPosition, endPosition); Sort(list, startPosition, pivotPosition - 1); Sort(list, pivotPosition + 1, endPosition); }}private static int Partition(IList<int> list, int startPosition, int endPosition){ int pivo = list[startPosition]; int startPartitionPosition = startPosition + 1, endPartitionPosition = endPosition; while (startPartitionPosition <= endPartitionPosition) { if (list[startPartitionPosition] <= pivo) startPartitionPosition++; else if (pivo < list[endPartitionPosition]) endPartitionPosition--; else { int troca = list[startPartitionPosition]; list[startPartitionPosition] = list[endPartitionPosition]; list[endPartitionPosition] = troca; startPartitionPosition++; endPartitionPosition--; } } list[startPosition] = list[endPartitionPosition]; list[endPartitionPosition] = pivo; return endPartitionPosition;}#endregion#endregion

Testes:using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class QuickSortTester : AbstractTester { [TestMethod] public void QuickSortTester_SortTwoItems() { //-- Arrange int[] expected = { 1, 2 }; int[] actual = { 2, 1 }; //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void QuickSortTester_SortFiveItems() { //-- Arrange int[] expected = { 1, 2, 3, 4, 5 }; int[] actual = { 2, 1, 4, 5, 3 }; //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void QuickSortTester_SortFiveItemsInOtherOrder() { //-- Arrange int[] expected = { 10, 12, 35, 43, 101 }; int[] actual = { 101, 35, 12, 10, 43 }; //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void QuickSortTester_SortTenItems() { //-- Arrange

int[] expected = { 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 6 }; //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void QuickSortTester_SortTenItemsWithRepetedValues() { //-- Arrange int[] expected = { 2, 4, 4, 8, 10, 12, 14, 16, 18, 20 }; int[] actual = { 14, 10, 20, 12, 4, 8, 2, 16, 18, 4 }; //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(expected, actual); } [TestMethod] public void QuickSortTester_SortOneHumdredItems() { //-- Arrange NumericListCreator numericListCreator = new NumericListCreator(100); int[] actual = numericListCreator.UnorderedList.ToArray<int>(); //-- Act actual.QuickSort(); //-- Assert CollectionAssert.AreEqual(numericListCreator.OrderedList, actual); } }}

4. Execução dos testes automatizados Para facilitar os testes automatizados para grandes vetores foi criado uma classe chamadaNumericListCreator que tem como objetivo criar dois vetores iguais com a diferença que umestá ordenado e o outro não. Quando criamos a instância desta classe informamos o tamanhodo vetor que queremos e ela disponibiliza duas propriedades, cada uma sendo um vetor. Para criar os dois vetores com os mesmos valores, foi utilizado um recurso do .NetFramework. Na verdade é um objeto chamado SortedList, que nada mais é do que uma listaque se ordena conforme vai incluindo os itens. Esta classe gera os vetores com no máximo cemmil posições. Veja abaixo a codificação desta classe:using System.Collections;using System.Collections.Generic;using Lorival.Collections;using System;namespace Tester{ internal class NumericListCreator { internal IList OrderedList { get; private set; } internal IList<int> UnorderedList { get; private set; } private const int limitGeneratedLists = 100000; internal NumericListCreator(int listSize) { OrderedList = new List<int>(); UnorderedList = new List<int>(); if (listSize > limitGeneratedLists) listSize = limitGeneratedLists; SortedList sortedList = new SortedList(); while(sortedList.Count < listSize) { int randowNumber = new Random().Next(limitGeneratedLists); if (!sortedList.ContainsKey(randowNumber)) { sortedList.Add(randowNumber, null); UnorderedList.Add(randowNumber); } } OrderedList = sortedList.GetKeyList(); } }}

Todos os testes foram escritos seguindo um pouco de babysteps. Começam comvetores de duas posições e vai aumentando até um vetor de 100 posições, gerado através doobjeto gerador de vetores já citado. Foi criada uma classe abstrata para os testes. Esta tem como único objetivo armazenarinformações pertinentes ao framework de testes. Veja abaixo:using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ public abstract class AbstractTester { /// <summary> ///Gets or sets the test context which provides ///information about and functionality for the current test run. ///</summary> public TestContext TestContext { get;set;} #region Additional test attributes // // You can use the following additional attributes as you write your tests: // // Use ClassInitialize to run code before running the first test in the class // [ClassInitialize()] // public static void MyClassInitialize(TestContext testContext) { } // // Use ClassCleanup to run code after all tests in a class have run // [ClassCleanup()] // public static void MyClassCleanup() { } // // Use TestInitialize to run code before running each test // [TestInitialize()] // public void MyTestInitialize() { } // // Use TestCleanup to run code after each test has run // [TestCleanup()] // public void MyTestCleanup() { } // #endregion }}

Abaixo segue o resultado da execução de todos os 36 testes.

5. Estatísticas entre os algoritmos de ordenação Abaixo segue tabelas comparando o tempo de execução dos algoritmos ordenandovetores. Para a realização dos testes foi gerado um vetor com valores aleatórios e utilizado omesmo vetor para todos os algoritmos. O programa utilizado será explicado após as tabelas decomparação.Ordenando vetores com 10 itensBubbleSort {00:00:00}SelectionSort {00:00:00.0010001}InsertionSort {00:00:00}MergeSort {00:00:00.0020002}MergeSortWithInsertionSort {00:00:00}QuickSort {00:00:00.0010001}Ordenando vetores com 100 itensBubbleSort {00:00:00.0012501}SelectionSort {00:00:00.0010001}InsertionSort {00:00:00.0012501}MergeSort {00:00:00.0012501}MergeSortWithInsertionSort {00:00:00.0012501}QuickSort {00:00:00.0012500}Ordenando vetores com 1000 itensBubbleSort {00:00:00.0179982}SelectionSort {00:00:00.0109989}InsertionSort {00:00:00.0069993}MergeSort {00:00:00.0029997}MergeSortWithInsertionSort {00:00:00.0019998}QuickSort {00:00:00.0019998}Ordenando vetores com 10000 itensBubbleSort {00:00:01.6988304}SelectionSort {00:00:01.0148985}InsertionSort {00:00:00.6489351}MergeSort {00:00:00.0749925}MergeSortWithInsertionSort {00:00:00.0569943}QuickSort {00:00:00.0059994}

Ordenando vetores com 50000 itensBubbleSort {00:00:41.9553894}SelectionSort {00:00:28.3195700}InsertionSort {00:00:16.4596458}MergeSort {00:00:01.2951295}MergeSortWithInsertionSort {00:00:01.1681168}QuickSort {00:00:00.0280028} Para implementar os extensions methods (orientação a aspectos) é necessário utilizarclasses estáticas. Estas por sua vez não permite herdar de interfaces o que inviabiliza aaplicação do command pattern. Pela ótica de como foi desenvolvido, o projeto responsável por contemplar o programaque gera as estatísticas foi o projeto de testes, visto que as estatísticas, neste caso, fazemparte dos testes de avaliação do software. Abaixo segue a classe que gerou as estatísticas apresentadas:using System;using System.Linq;using Lorival.Collections;using Microsoft.VisualStudio.TestTools.UnitTesting;namespace Tester{ [TestClass] public class SpeedTester : AbstractTester { [TestMethod] public void EffectTest() { DateTime startTime; DateTime endTime; startTime = DateTime.Now; NumericListCreator numericListCreator = new NumericListCreator(50000); endTime = DateTime.Now; TimeSpan numericListCreatorSpeedTime = endTime - startTime; startTime = DateTime.Now; int[] bubble = numericListCreator.UnorderedList.ToArray<int>(); bubble.BubbleSort(); endTime = DateTime.Now; TimeSpan bubbleSpeedTime = endTime - startTime; //-- startTime = DateTime.Now; int[] selection = numericListCreator.UnorderedList.ToArray<int>(); selection.SelectionSort(); endTime = DateTime.Now; TimeSpan selectionSpeedTime = endTime - startTime; //-- startTime = DateTime.Now;

int[] insertion = numericListCreator.UnorderedList.ToArray<int>(); insertion.InsertionSort(); endTime = DateTime.Now; TimeSpan insertionSpeedTime = endTime - startTime; //-- startTime = DateTime.Now; int[] merge = numericListCreator.UnorderedList.ToArray<int>(); merge.MergeSort(); endTime = DateTime.Now; TimeSpan mergeSpeedTime = endTime - startTime; //-- startTime = DateTime.Now; int[] mergeWithInsertion = numericListCreator.UnorderedList.ToArray<int>(); mergeWithInsertion.MergeSortWithInsertionSort(); endTime = DateTime.Now; TimeSpan mergeWithInsertionSpeedTime = endTime - startTime; //-- startTime = DateTime.Now; int[] quick = numericListCreator.UnorderedList.ToArray<int>(); quick.QuickSort(); endTime = DateTime.Now; TimeSpan quickSpeedTime = endTime - startTime; } }}

6. Conclusão Os objetivos do trabalho foram alcançados com sucesso, ou seja, foi possível construirtodos os algoritmos e apresenta-los neste relatório juntamente com estatísticas dedesempenho de cada um. O tempo aproximado total utilizado para desenvolvimento e geração deste relatóriofoi de doze horas. Os testes unitários foram imprescindíveis para a perfeita conclusão de todos osalgoritmos. Mesmo depois de concluído cada um, foi necessário passar por uma fase derevisão e refinação o que permitiu serem feitas de forma muito mais rápidas e assertivas, vistoque existiam testes validando a ordenação de todos os algoritmos. O maior problema encontrado foi na geração de um vetor não ordenado com valoresaleatórios para a realização dos testes. Como esta era uma responsabilidade do projeto detestes foi possível utilizar o “SortedList” para facilitar o desenvolvimento, porém o tempo parageração de um vetor de 50 mil posições sem valores repetidos foi de quase 20 minutos.Existem várias outras formas de gerar este vetor, porém como não fazia parte dos objetivospropostos e fazia parte apenas dos testes foi utilizada a forma mais rápida de desenvolver, queimplicou unicamente em ter maior tempo de espera na geração das estatísticas. Por fim o trabalho foi de grande valia para entendimento, principalmente, dasdiferenças de desempenho entre os algoritmos de ordenação e compreender que sempreexistem métodos mais eficientes de resolver um problema recorrente.

Algoritmos de ordenação

by Lorival Smolski Chapuis on Jun 20, 2011

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 632

Statistics

Algoritmos de ordenação — Document Transcript

http://blog.lorival.com	623
http://www.slideshare.net	9