Trabalho Algoritmos -, Trabalhos de Economia Agroindustrial

Baixe Trabalho Algoritmos - e outras Trabalhos em PDF para Economia Agroindustrial, somente na Docsity!

UNIVERSIDADE ESTADUAL DE MARINGÁ

CENTRO DE TECNOLOGIA

DEPARTAMENTO DE INFORMÁTICA

Avaliação de Algoritmos de Ordenação

Acadêmicos: RA:

Prof.

MARINGÁ,

1 - INTRODUÇÃO

O Trabalho da disciplina Algoritmo e Estrutura de Dados foi dividido em duas partes: a implementação e a explicação de alguns algoritmos de ordenação. São eles:

1. BubbleSort;
2. InsertionSort;
3. SelectionSort;
4. MergeSort;
5. HeapSort;
6. QuickSort; Lembrando que, algoritmo de ordenação em ciência da computação é um algoritmo que coloca os elementos de uma dada sequência em uma certa ordem - em outras palavras, efetua a ordenação das chaves de um vetor.

2. IMPLEMENTAÇÃO DOS ALGORITMOS

2.1 BubbleSort:..................................................................................................

void bubbleSort (int vetor[], int tamanho) { int k, j, aux; for (k = 1; k < tamanho; k++) { for (j = 0; j < tamanho - 1; j++) { if (vetor[j] > vetor[j + 1]) { aux = vetor[j]; vetor[j] = vetor[j + 1]; vetor[j + 1] = aux;

}

}

2.2 InsertionSort.................................................................................................

void insertionSort(int vetor[], int tamanhoVetor ) {

min = j; } if (vetor[i] != vetor[min]) { aux = vetor[i]; vetor[i] = vetor[min]; vetor[min] = aux; }

}

}

2.4 MergeSort:...................................................................................................

void merge(int vetor[], int inicio, int meio, int fim) { int com1 = inicio, com2 = meio+1, comAux = 0; int vetAux[fim-inicio+1]; while(com1<=meio && com2<=fim){ if(vetor[com1] <= vetor[com2]){ vetAux[comAux] = vetor[com1]; com1++; }else{ vetAux[comAux] = vetor[com2]; com2++; } comAux++; } while(com1<=meio){ vetAux[comAux] = vetor[com1]; comAux++;com1++; } while(com2<=fim){ vetAux[comAux] = vetor[com2]; comAux++;com2++; }

int pivo, aux, i, j, meio; i = inicio; j = fim; meio = (int) ((i + j) / 2); pivo = vetor[meio]; do{ while (vetor[i] < pivo) i = i + 1; while (vetor[j] > pivo) j = j - 1; if(i <= j){ aux = vetor[i]; vetor[i] = vetor[j]; vetor[j] = aux; i = i + 1; j = j - 1; }

}while(j > i);

if(inicio < j) quickSort(vetor, inicio, j); if(i < fim) quickSort(vetor, i, fim);

}

2.6 HeapSort......................................................................................................

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

printf("\n");

}

3. EXPLICAÇÃO DO ALGORITMO

3.1 BubbleSort:................................................................................................

O algoritmo do bubblesort consiste em percorrer o vetor N -1 vezes, onde N é o tamanho do vetor, para cada vez que o vetor é percorrido é comparado de 2 em 2 elementos para saber qual elemento é o maior e sempre comparando o 1º com o 2º elemento, 2º com o 3º e sempre mantendo o maior valor da comparação para frente, por exemplo: No seguinte vetor (1 6 3 2), no primeiro percurso é comparado os elementos 1 e 6 primeiramente, como o 6 é maior não há alteração, em seguida é comparado o 6 com o 3, nesse caso o 6 é maior então os valores são trocados de lugares, ficando dessa forma (1 3 6 2), continuando o percurso é comparado o 6 com o 2 e novamente os valores são trocados (1 3 2 6). Dessa forma, após o primeiro percurso o último elemento estará ordenado, no próximo percurso o penúltimo elemento estará ordenado e assim por diante, após percorrer N – 1 percurso, todos os elementos estão ordenados.

A comparação 6 5 4 3 funciona assim:

6 5 4 3 = 5 6 4 3 5 6 4 3 = 5 4 6 3 5 4 6 3 = 5 4 3 6

primeiro percurso primeiro comparação: 6 5 4 3 resultado: 5 6 4 3 segunda comparação: 5 6 4 3 resultado: 5 4 6 3 terceira comparação: 5 4 6 3 resultado: 5 4 3 6

O próximo elemento é o 4 (terceiro elemento): 5 6 4 3 o 4 se encaixa antes do 5, então ele é inserido antes do 5 ficando: 4 5 6 3 o proximo alvo é o 3: 4 5 6 3 seguindo a mesma logica o vetor final fica 3 4 5 6

3.3 SelectionnSort:........................................................................................

O selctionsort também percorre o vetor N -1 vezes para ordenar as chaves. A cada vez que ele percorre o vetor ele seleciona o menor elemento do vetor e coloca na posição do número do percurso por exemplo: 6 5 3 2

Primeiro percurso : verifica quem é o menor valor do vetor e coloca na primeira posição. Nesse caso ele vê que o 2 é o menor e troca com o 6 que é a primeira posição

No segundo percurso ele pega o segundo menor valor, já que o 2 já esta ordenado, nesse caso é o 2 5 4 6 pega-se o 4 e troca-se pelo valor da segunda posição já que esta no segundo percurso 2 4 5 6 no terceiro percurso pega-se o terceiro menor valor desconsiderando o 2 e o 4 já que eles já estão ordenados o menor valor é o próprio 5 que já está na terceira posição, dessa forma não há troca de valores. No fim de todos os percursos o vetor vai estar ordenado.

3.4. MergeSort:................................................................................................

O merge sort, ou ordenação por mistura, é um exemplo de algoritmo de ordenação por comparação do tipo dividir-para-conquistar. A ideia da estrutura consiste em Dividir o problema em vários sub-problemas e resolver esses sub-problemas através da recursividade e Conquistar que é após todos os sub-problemas terem sido resolvidos ocorre a união das resoluções dos sub-problemas. Como o algoritmo Merge Sort usa a recursividade, há um alto consumo de memória e tempo de execução, tornando esta técnica não muito eficiente em alguns problemas. Os três passos dos algoritmos de divisão e conquista, que se aplicam ao MergeSort são:

1. Dividir: Calcula o ponto médio do sub-arranjo, o que demora um tempo constante {\displaystyle \Theta (1)};
2. Conquistar: Recursivamente resolve dois sub-problemas, cada um de tamanho n/2, o que contribui com {\displaystyle 2T(n/ 2)} para o tempo de execução;
3. Combinar: Unir os sub-arranjos em um único conjunto ordenado, que leva o tempo {\displaystyle \Theta (n)}.

final e haverá duas sublistas não ordenadas. Essa operação é denominada partição; Recursivamente ordene a sublista dos elementos menores e a sublista dos elementos maiores; A base da recursão são as listas de tamanho zero ou um, que estão sempre ordenadas. O processo é finito, pois a cada iteração pelo menos um elemento é posto em sua posição final e não será mais manipulado na iteração seguinte.

4. REFERÊNCIAS BIBLIOGRÁFICAS

• Projetos de algoritmos com implementações em pascal e c - Nivio Ziviani;
• Algoritmos (3ª edição), Cormen, Thomas H.; Leiserson, Charles E.; Rivest, Ronald L.; Stein, Clifford (2009) [1990];
• https://www.ime.usp.br/~pf/mac0122-2002/.