Instituto Federal do Triangulo Mineiro
Campus Uberlândia-Centro
Licenciatura em Computação
APOSTILA DE
ALGORITMOS E
ESTRUTURAS DE DADOS
Prof. Walteno Martins Parreira Júnior
www.waltenomartins.com.br
2015
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
Guias e Dicas
Prepare-se para as provas
Estude fácil! Tem muito documento disponível na Docsity
Encontrar documentos
Prepare-se para as provas com trabalhos de outros alunos como você, aqui na Docsity
Encontra documentos específicos para os exames da tua universidade
Encontra documentos específicos para os exames da tua universidade
Videoaulas
Prepare-se com as videoaulas e exercícios resolvidos criados a partir da grade da sua Universidade
Quiz
Responda perguntas de provas passadas e avalie sua preparação.
Ganhe pontos para baixar
Ganhe pontos ajudando outros esrudantes ou compre um plano Premium
informatica para engenheiros, Notas de estudo de Informática
n khvkhvjhcklkn~lmçkjbvhjvjbn ,m .m bvhgcyxhgcjbc hgxhfxyfxhgfxchfxhyrzkuttc
Tipologia: Notas de estudo
2020
1 / 51
Esta página não é visível na pré-visualização
Não perca as partes importantes!
Documentos relacionados
Pré-visualização parcial do texto
Baixe informatica para engenheiros e outras Notas de estudo em PDF para Informática, somente na Docsity!
Instituto Federal do Triangulo Mineiro
Campus Uberlândia-Centro
Licenciatura em Computação
APOSTILA DE
ALGORITMOS E
ESTRUTURAS DE DADOS
Prof. Walteno Martins Parreira Júnior
www.waltenomartins.com.br
[email protected] [email protected]
Sumário
- 1 – Desenvolvimento de Algoritmos
- 1.1 – Introdução
- 1.2 – O que é um algoritmo
- 1.3 – Medidas de Complexidade
- 1.4 – Análise de Complexidade de um algoritmo
- 1.5 – Notação O
- 1.6 – Convenções para as expressões de O........................................................................................................
- 1.7 – Exemplo de análise da notação O
- 1.8 – Análise de complexidade da Busca Linear
- 1.8.1 – Pior Caso
- 1.8.2 – Caso Médio
- 1.8.3 – Melhor Caso
- 1.8.4 – Um exemplo numérico
- 1.9 – Exercícios
- 1.10 - Exercício Prático Algoritmo Busca a primeira ocorrência:
- 2 – Divisão e Conquista.......................................................................................................................................
- 2.1 – Máximo e Mínimo de uma lista
- 2.2 – Exercício MaxMin
- 2.3 – Ordenação por Intercalação
- 2.4 – Ordenação por Concatenação
- 2.5 – Busca Binária
- 2.6 – Exercício prático de Busca Binária.........................................................................................................
- 2.7 - Lista de Exercícios da Unidade
- 3 - Métodos de Ordenação
- 3.1 - Métodos de Ordenação Interna
- 3.2 - Método de ordenação por Seleção...........................................................................................................
- 3.2.1 - Algoritmo de Ordenação por seleção:
- 3.2.2 - Análise de complexidade
- 3.3 - Método de ordenação por Inserção
- 3.3.1 - Algoritmo de Ordenação por Inserção
- 3.3.2 - Análise de complexidade do algoritmo
- 3.4 - Método de ordenação Quicksort
- 3.4.1 - Algoritmo Partição
- 3.4.2 - Versão recursiva do Quicksort
- 3.4.3 - Outra versão recursiva do Quicksort
- 3.4.4 - Versão iterativa do Quicksort
- 3.4.5 - Conclusão
- 3.5 - Método de ordenação Shellsort
- 3.5.1 – Algoritmo Shellsort
- 3.5.2 - Análise do algoritmo
- 3.6 - Método de ordenação Heapsort
- 3.6.1 - Fila de prioridades
- 3.6.2 - Heaps................................................................................................................................................
- 3.6.3 - Heapsort
- 3.6.4 - Análise de complexidade do Heapsort
- 3.6.5 - Conclusão
- 3.7 - Comparação entre os métodos de ordenação...........................................................................................
- 3.8 - Exercícios
- 3.9 – Exercício prático de Ordenação
- 3.9.1 – Exercício prático com os algoritmos “Inserção” e “seleção”
- 3.9.2 – Exercício prático com os algoritmos de ordenação
uma função em “n” do número de comparações efetuadas pelo algoritmo, para valores grandes de “n”.
A complexidade assintótica de um algoritmo é que determina o tamanho de problemas que pode ser solucionado pelo algoritmo. Se o algoritmo processa entradas de tamanho “n” no tempo cn*^2 , para alguma constante c , então dizemos que a complexidade de tempo do algoritmo é O(n^2 ), onde se lê: “ de ordem n 2 ”.
Suponha que temos cinco algoritmos A1,...A5 com as seguintes complexidades de tempo:
Algoritmo Complexidade de tempo A 1 n A 2 n log 2 n A 3 n 2 A 4 n 3 A 5 2 n
A complexidade de tempo é o número de unidades de tempo (UT) necessárias para processar uma entrada de tamanho n. A unidade de tempo é medida em um milisegundo, portanto: 1UT = 1ms = 10-3^ segundos
A tabela a seguir mostra o tamanho de problemas que podem ser resolvidos em 1 segundo, em 1 minuto e em 1 hora para cada algoritmo em um computador hipotético:
Algoritmo Complexidade de tempo 1 segundo 1 minuto 1 hora A 1 n 1.000 60.000 3.600. A 2 n log 2 n 140 4893 200. A 3 n 2 31,6 244,9 1.897, A 4 n 3 10 39,2 153, A 5 2 n^9 15
Cálculos, A 1 :
T(n) = n * UT T(n) = n * UT T(n) = n * UT 1 = n * 10 -3^ 60 = n * 10 -3^ 3600 = n * 10 - n = 1000 n = 60000 n = 36 * 10 5
A 2 :
T(n) = n log n* UT T(n) = n log n* UT T(n) = n log n* UT 1 = n log n * 10 -3^ 60 = n log n * 10 -3^ 3600 = n log n * 10 - n log n = 10 3 n log n= 6 * 10^4 n log n = 36 * 10 5 n = 140 n = 4893 n = 2 * 10 5
A 3 :
T(n) = n 2 * UT T(n) = n 2 * UT T(n) = n 2 * UT 1 = n 2 * 10 -3^ 60 = n 2 * 10 -3^ 3600 = n 2 * 10 - n = 31,6 n = 244,9 n = 1897,
A 4 :
T(n) = n 3 * UT T(n) = n 3 * UT T(n) = n 3 * UT 1 = n 3 * 10 -3^ 60 = n 3 * 10 -3^ 3600 = n 3 * 10 - n = 10 n = 32,9 n = 153,
A tabela apresenta uma comparação relativa de grandeza para várias funções que podem ser encontradas em algoritmos. Podemos ter a noção da ordem de crescimento dos algoritmos.
Tipo de Função n Log 2 n n N log 2 n n 2 n 3 2 n 1 0 1 0 1 1 2 10 3,32 10 33 100 1000 1024 100 6,64 100 664 10.000 1.000.000 1,26810 30 1000 9,97 1000 9970 1.000.000 10 9 1,07210 301
Supondo que a próxima geração de computadores seja dez vezes mais rápido que a atual. A tabela abaixo mostra o aumento no tamanho do problema que o algoritmo possa resolver no mesmo tempo.
Algoritmo Complexidade de tempo Máximo atual Máximo após aumento A1 n S1 10 * S A2 n log 2 n S2 10 * S A3 n 2 S3 (^) 3 * S A4 n 3 S4 2 * S A5 2 n^ S5 S5 + 3
Cálculos: A1 A3 A Atual: T(n) = S1 * 1 UT Atual: T(n) = S3 * 1 UT Atual: T(n) = 2S5^ * 1 UT Futuro: T´(n) = ( n * 1UT) / 10 Futuro: T´(n) = ( n 2 * 1UT) / 10 Futuro: T´(n) = ( 2 n^ * 1UT) / 10 T(n) = T´(n) T(n) = T´(n) T(n) = T´(n) S1 * 1 UT = (n * 1UT) / 10 S3 * 1 UT = (n^2 * 1UT) / 10 2 S5^ * 1 UT = ( 2 n^ * 1UT) / 10 .n = 10 * S1 .n 2 = 10 S3 2 S5^ = 2 n^ / .n 3 S3 2 n^ = 10 * 2^ n^ = 10 * 2^ S .n = log 2 10 + S .n = 3 + S
Comparação de várias funções de complexidade, segundo Ziviani:
Valor de n Função de Complexidade 20 40 60 .n 0,0002 segundos 0,0004 segundos 0,0006 segundos .n log n 0,0009 segundos 0,0021 segundos 0,0035 segundos .n 2 0,004 segundos 0,016 segundos 0,036 segundos .n 3 0,08 segundos 0,64 segundos 2,16 segundos 2 n^ 10 segundos 127 dias 3660 séculos 3 n^ 580 minutos 38550 séculos 1,3*10^14 séculos
1.4 – Análise de Complexidade de um algoritmo
A finalidade de se fazer a análise de complexidade de um algoritmo é obter estimativas de tempos de execução de programas que implementam esse algoritmo. A complexidade do algoritmo dá ideia do esforço computacional do programa, que é uma medida do número de operações executadas pelo programa.
Uma das preocupações com a eficiência é com problemas que envolvem um considerável número de elementos. Se existir uma tabela com apenas dez elementos, mesmo o algoritmo considerado menos eficiente resolve o problema, no entanto, à medida que o número de elementos aumenta, o esforço necessário começa a fazer diferença de algoritmo para algoritmo.
O que se deseja na verdade é uma avaliação do desempenho do algoritmo independentemente da sua implementação, em função somente do número de instruções executadas para entradas determinadas. São consideradas somente a instruções preponderantes, isto é, as operações básicas para a execução do algoritmo. O número de vezes que essas operações são executadas é denominado Complexidade do Algoritmo.
Em geral, a complexidade de um algoritmo depende da entrada e esta é caracterizada pelo seu tamanho, por seus valores e também pela configuração dos dados.
De forma intuitiva, sabemos que a complexidade depende da quantidade de dados que são processados e isso se traduz pelo tamanho da entrada: o número de operações executadas para localizar o último registro de uma lista com 1000 registros deve ser maior que o de uma lista com apenas 10 registros. Muitas vezes, o valor da entrada determina o esforço, por exemplo, na execução de uma busca em uma lista linear não ordenada, o número de comparações executadas varia muito conforme o valor procurado ocorrer no primeiro registro, no final ou no meio da lista.
Por exemplo, nos algoritmos que executam operações sobre listas lineares, a complexidade é expressa em função do tamanho da lista. Se n indica o número de registros, temos que a complexidade será uma função de n. Por outro lado, como os valores ou a configuração dos dados de entrada são fatores que também interferem no processo, não é possível obter uma única função que descreva todos os casos possíveis. Para cada possibilidade de entrada há uma função de complexidade do algoritmo. Reduzimos o estudo para alguns casos especiais:
a) Pior Caso, caracterizado por entradas que resultam em maior crescimento do número de operações, conforme aumenta o valor de n; b) Melhor Caso, caracterizado por entradas que resultam em menor crescimento do número de operações, conforme aumenta o valor de n; c) Caso Médio, que retrata o comportamento médio do algoritmo, quando se consideram todas as entradas possíveis e as respectivas probabilidades de ocorrência (esperança matemática). Somente o estudo da complexidade de algoritmos permite a comparação de dois algoritmos equivalentes, isto é, desenvolvidos para resolver o mesmo problema.
1.5 – Notação O
A notação O (leia-se ó grande , ou big oh ) é utilizada para expressar comparativamente o crescimento assintótico que representa a velocidade com que uma função tende ao infinito. No estudo de complexidade de algoritmos é mais interessante saber como se comporta essa função à medida que aumentarmos o valor de n, do que conhecer valores da função correspondentes a particulares valores de n.
Por exemplo, é mais importante saber que o número de operações executadas num algoritmo dobra se dobrarmos o valor de n, do que saber que para n igual a 100 são executadas 300 operações.
Ao dizermos que uma função de complexidade f(n) é da ordem de n 2 , queremos dizer que as duas funções, f(n) e n^2 tendem ao infinito com a mesma velocidade, ou que têm o mesmo comportamento assintótico. Indicamos por
f(n) = O(n^2 )
em matemática essa informação é expressa por um limite:
lim f(n) (^) = c ( c > 0) n (^) n 2
Se, por exemplo, outro algoritmo para o mesmo problema tem função de complexidade f 1 (n) = O(n), podemos comparar f(n) e f 1 (n) e, em consequência, comparar a eficiência dos programas que os implementam. Em um deles, o tempo de execução é linear e no outro, o tempo é quadrático.
Função Significado ( tamanho da entrada = n) 1 tempo constante – o número de operações é o mesmo para qualquer tamanho da entrada n tempo linear – se n dobra, o número de operações também dobra n^2 tempo quadrático – se n dobra, o número de operações quadruplica log n tempo logarítmico – se n dobra, o número de operações aumenta de uma constante nlog n tempo n log n - se n dobra, o número de operações ultrapassa o dobro do tempo da entrada de tamanho n 2 n^ tempo exponencial - se n dobra, o número de operações é elevado ao quadrado
Pode-se observar na linha 2 a estrutura de repetição enquanto que percorre a matriz de 1 até N e para cada incremento da linha 2, a linha 4 percorre a matriz de 1 a N (portanto N execuções), onde N é o tamanho da matriz, logo N x N = N 2. Essa é uma situação clássica da repetição quadrática. A eficiência do algoritmo é O(n 2 ).
O segundo exemplo, supondo a multiplicação de duas matrizes m 1 e m 2 , cujo resultado será colocado na matriz m 3 , podemos considerar o seguinte algoritmo:
1 coluna 1 2 enquanto (coluna tamanho_da_matriz ) faça 3 col 1 4 enquanto (col tamanho_da_matriz ) faça 5 m3 [ linha, col ] 0 6 k 1 7 enquanto (k tamanho_da_matriz ) faça 8 m3 [ linha, col ] m3 [ linha, col ] + m1 [ linha, k ] * m2 [ k, col ] 9 k k + 1 10 fim-enquanto 11 col col + 1 12 fim-enquanto 13 coluna coluna + 1 14 linha linha + 1 15 fim-enquanto
Fazendo uma análise deste algoritmo, nota-se a presença de três estruturas de repetição (linhas 2, 4 e 7) aninhadas. Como cada uma delas serão iniciada e finalizada no primeiro elemento, observa-se a presença de uma repetição cúbica. A eficiência do algoritmo é O(n^3 ).
Pode-se mostrar outro exemplo para ilustrar os passos a serem executados, para isto, calcular a notação O da seguinte função: f(n) = 4n^2 + 2n + 3
primeiramente assumir que os coeficientes são iguais a 1, logo f(n) = n^2 + n + em seguida são removidos os fatores de menor importância: f(n) = n 2 finalmente, a notação será: O(f)n)) = O(n^2 )
1.8 – Análise de complexidade da Busca Linear
Nos algoritmos de operações em listas o parâmetro utilizado na análise de complexidade é o tamanho da lista, indicado por n. A operação preponderante em operações de busca é a comparação de valores dos registros.
Vamos considerar dois casos neste estudo: W(n) = número de comparações no pior caso; A(n) = número de comparações no caso médio. A(n) = número de comparações no melhor caso.
O algoritmo que vamos analisar é o algoritmo de busca da primeira ocorrência de um valor x na lista A. Supomos que A tenha n registros. A sequência de instruções abaixo é o algoritmo “BuscaPrimeiraOcorrencia”: 1 j 1 2 enquanto ( A[ j ] x ) e (j < n) faça 3 j j + 1 4 fim-enquanto 5 se A[ j ] x 6 então sinal false 7 senão 8 sinal true 9 local j 10 fim-senão
A função de complexidade deve indicar, portanto, o número de vezes que é testada a condição (A[j] x).
1.8.1 – Pior Caso
A condição A[j] x ocorre como condição de controle do loop e, mais uma vez após o mesmo, na instrução de seleção.
A outra condição que controla o loop, ( j < n), limita o número de repetições do loop a n -
- Isto é, se a primeira condição tiver sempre o valor false, o loop será executado n-1 vezes, porque j é inicializado com valor 1. Entretanto, a condição que controla o loop é avaliada n vezes, que são as n -1 vezes que o loop é executado mais uma vez quando j atinge o valor n e torna a condição (j<n) falsa. Logo,
W(n) = n + 1 comando de seleção loop por outro lado, temos que W(n) = O(n), pois lim W(n) = 1 n (^) n
1.8.2 – Caso Médio
Se uma lista contém n registros, as possíveis entradas numa operação de busca são correspondentes a um valor x procurado em que: x ocorre no primeiro registro, ou x ocorre no segundo registro, ou x ocorre no terceiro registro, e assim por diante, ou x ocorre no último registro, ou ainda, x não pertence à lista. São, portanto, n+1 casos diferentes de entradas possíveis.
A cada uma dessas entradas devemos associar um número de probabilidade de que a entrada ocorra. Vamos supor que todas as entradas sejam igualmente prováveis, portanto com probabilidade igual a 1/(n+1).
Assim, A(n) = p 1 xC 1 + p 2 xC 2 + ... + p (^) n+1 xCn+ Pode-se concluir que: A(n) = O( log n)
1.9 – Exercícios
1.9.1 - Considerando a comparação como operação elementar, determine a complexidade do algoritmo abaixo: a) MAIOR (N, A) max A [ 1 ] para i de 2 até N repita Se max < A[ i ] então max A[ i ]
b) ORDENA ( N, A) para i de 1 até (N – 1) repita para j de 1 até (n – i ) repita se A[ j ] > A[ j + 1 ] então x A[ j ] A[ j ] A[ j + 1 ] A[ j + 1 ] x
c) n 1 enquanto (n 10) faça k 1 enquanto ( k 10 ) faça ... trecho de pseudocódigo k K + 1 fim-enquanto n n + 1 fim-enquanto
1.9.2 – verifique se as funções abaixo são O(n): a) f(n) = n b) f(n) = 1045n c) f(n) = n 2 + 70 d) f(n) = 7n + 3 e) f(n) = Cn + D , onde C, D são constantes f) f(n) = 8 g) f(n) = n 3 + n + 1 h) f(n) = 4n + 2log n + 5
1.9.3 – Obter o valor de O para as expressões de complexidade: a) f(n) = 3n 3 + n b) f(n) = 3 log n + 5n c) f(n) = 3n 2 + 5n + 4 d) f(n) = 3n 3 + n^2 + 5n + 99
1.10 - Exercício Prático Algoritmo Busca a primeira ocorrência:
Desenvolver no laboratório o algoritmo “BuscaPrimeiraOcorrencia” em Pascal ou C. Executar o exercício para uma lista com n = 11, 21 e 42 elementos. Para cada lista, x ( o elemento procurado) deve estar na 2ª posição, na posição mediana ( 6, 11 e 21) e para x não existente. Os valores devem ser atribuídos no próprio programa fonte ou lidos uma única vez no início da execução. a) colocar um contador após o enquanto e dentro do teste (se). Ao final de cada execução imprimir o contador. Ao final das execuções, fazer uma tabela e comparar os resultados encontrados. b) no lugar do contador, colocar um delay. Ao iniciar a execução da rotina armazenar o horário do sistema e ao terminar a execução calcular o tempo gasto. Ao final das execuções, fazer uma tabela e comparar os resultados encontrados. c) Fazer um documento texto analisando os dados encontrados. Apresentar as tabelas com os dados encontrados. O que voce pode concluir observando os dados encontrados nos itens a e b e a teoria apresentada? A entrega do trabalho é em arquivo digital, onde deve conter o programa-fonte e o arquivo texto (em texto puro ou no word 97). No programa-fonte deve conter o(s) nome(s) do(s) aluno(s) responsável(ies), o que deve ser feito quando mais de um aluno desenvolveu o programa, sendo aceito no máximo três (3) alunos. Deve apresentar também comentários explicando as principais passagens desenvolvidas. No arquivo texto com os dados e as conclusões, deve conter o nome do aluno, e a informação (quando necessária) de que o programa foi desenvolvido juntamente com outros alunos (colocar os nomes) e em seguida os dados coletados e as conclusões. Observe que este arquivo é individual e as execuções para coleta dos dados também devem ser individuais.
Exemplo do uso do delay e de um controlador de tempo em linguagem C: #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <time.h> #include <dos.h>
clock_t inicio, fim; //declaração de variáveis: tempo de inicio e do final da execução
....
inicio = clock(); //capturando o tempo de inicio da execução
.... // parte da execução e que deve incluir o delay()
delay(100); //para que o programa demore mais para ser executado ...
fim = clock(); //capturando o tempo de final de execução
....
printf("\nTempo de execucao: %f.",(fim - inicio)/CLK_TCK); //calculo do tempo total = fim - inicio
senão Se A[I] < min então min A[I]; O melhor caso ocorre quando os elementos de A estão em ordem crescente, portanto N- comparações são necessárias.
O pior caso ocorre quando os elementos de A estão em ordem decrescente, portanto 2(N-
- comparações são necessárias..
No caso médio, A[I] é maior do que max a metade das vezes, portanto (3N/2 – 3/2) comparações são necessárias.
Considerando o número de comparações realizadas, podemos desenvolver um algoritmo mais eficiente, observando: a) comparando os elementos de A aos pares, separando-os em dois subconjuntos de acordo com o resultado da comparação, os maiores em um subconjunto e os menores no outro subconjunto, a um custo de N/2 comparações;
b) o máximo é obtido do subconjunto que contém os maiores elementos, a um custo (N/2)- comparações;
c) o mínimo é obtido do subconjunto que contém os menores elementos, a um custo (N/2)- comparações.
O algoritmo é escrito:
objetivo: encontrar o maior e o menor elemento da lista; entradas: A (lista), N (inteiro) saídas: max (inteiro), min (inteiro) maxmim3 (A, max, min) Se (N mod 2) > 0 então A[N+1] A[N] FimDoAnel N senão FimDoAnel N-1; Se A[1] > A[2] então max A[1] min A[2] senão max A[2] min A[1]; I 3; Enquanto I FimDoAnel repita Se A[I] > A[I+1] então Se A[I] > max então max A[I]; Se A[I+1] < min então min A[I+1]; senão Se A[I] < min então min A[I]; Se A[I+1] > max então max A[I+1]; I I + 2; FimEnquanto
Os elementos de A são comparados de dois em dois e os elementos maiores são comparados com max e os menores com min. Quando N é impar, o elemento que está na posição A[N] é duplicado na posição A[N+1] para evitar um tratamento de exceção.
Este algoritmo faz (3N/2 – 2) comparações, independentemente da ordenação inicial da lista.
A tabela abaixo apresenta uma comparação entre os algoritmos, considerando o número de comparações como medida de complexidade.
Algoritmo Melhor caso Pior caso Caso médio maxmim 2 (n – 1) 2 (n – 1) 2 (n – 1) maxmin2 n – 1 2 (n – 1) 3n/2 – 3/ maxmin3 3n/2 – 2 3n/2 – 2 3n/2 – 2
Os algoritmos maxmin2 e maxmin3 são superiores ao maxmin de forma geral. O algoritmo maxmin3 é superior ao maxmin2 com relação ao pior caso, e é bastante próximo quanto ao caso médio.
Pode-se desenvolver um algoritmo mais rápido através da técnica de divisão e conquista. Para isto, dividimos a instancia L em duas sub-instancias L 1 e L 2 de comprimentos aproximadamente iguais: L 1 = (M 1 , M 2 , ..., M (^) k ) , onde k = N/ L 2 = (M (^) k+1 , M (^) k+2 , ..., M (^) n)
Resolvemos o problema considerando as sublistas L 1 e L 2 , separadamente, obtendo-se as soluções (max 1 , min 1 ) para L 1 e (max 2 , min 2 ) para L 2. Para achar a solução, max será o maior entre max 1 e max 2 e min será o menor entre min 1 e min 2. Podemos notar que o algoritmo é recursivo, onde cada sublista pode ser novamente dividida.
A seguir a versão recursiva do algoritmo maxmin, onde consideramos o algoritmo para obter o maior e o menor elemento de um vetor de inteiros A[1...N] tal que N 1.
objetivo: encontrar o maior e o menor elemento da lista; entradas: Linf (inteiro), Lsup (inteiro) saídas: max (inteiro), min (inteiro) maxmim4 (Linf, Lsup, max, min) Se Lsup - Linf 1 então Se A[Linf] < A[Lsup] então max A[Lsup] min A[Linf] senão max A[Linf] min A[Lsup]; senão meio (Linf + Lsup) div 2 maxmin4(Linf, meio, max1, min1) maxmin4(meio+1, Lsup, max2, min2) Se max1 > max2 então max max senão max max2; Se min1 < min2 então min min senão min min2;
Portanto, comparado com as 2 ( n – 1) comparações realizadas pelo algoritmo trivial (MaxMin), o MaxMin4 faz uma economia de aproximadamente 25% no número de comparações. Deve-se observar que (3n/2 –2) é o número de comparações tanto pessimista quanto média do algoritmo MaxMin4.
2.2 – Exercício MaxMin
Desenvolver no laboratório os algoritmos “MaxMin”, “MaxMin2”, ”MaxMin3” e “MaxMin4” em linguagem C.
Executar o exercício para uma lista com 40 elementos. Onde a situação inicial é: a) Uma lista qualquer; b) Uma lista gerada aleatoriamente pelo programa; c) Uma lista já ordenada ascendente; d) Uma lista já inversamente ordenada, isto é, ordenada descendente.
Os valores devem ser atribuídos no próprio programa fonte ou lidos uma única vez no início da execução. a) colocar um contador para calcular o número de comparações executadas. Ao final de cada execução imprimir o contador. Ao final das execuções, fazer uma tabela e comparar os resultados encontrados. b) no lugar do contador, colocar um delay. Calcular o tempo gasto. Ao final das execuções, fazer uma tabela e comparar os resultados encontrados. c) Fazer um documento texto analisando os dados encontrados. Deve apresentar as tabelas com os dados encontrados e os valores esperados, quando possível. O que voce pode concluir observando os dados encontrados nos itens a e b e a teoria apresentada?
A entrega do trabalho é em dois arquivos digitais, onde o primeiro deve conter o programa- fonte e segundo arquivo texto (no word 2003 ou anterior).
No programa-fonte deve conter o(s) nome(s) do(s) aluno(s) responsável(ies), o que deve ser feito quando mais de um aluno desenvolveu o programa, sendo aceito no máximo três (3) alunos. O programa fonte deve apresentar também comentários explicando as principais passagens desenvolvidas.
No arquivo texto deve estar os dados coletados para cada situação proposta e para cada uma deve ter o número de comparações e tempo gasto, e as conclusões do aluno. Este arquivo deve conter o nome do aluno, e a informação (quando necessária) de que o programa foi desenvolvido juntamente com outros alunos (colocar os nomes) e em seguida os dados coletados e as conclusões. Observe que este arquivo é individual e as execuções para coleta dos dados também devem ser individuais.
2.3 – Ordenação por Intercalação
Considerando o problema de ordenar uma lista de n objetos solucionado anteriormente por um algoritmo O(n 2 ). Podemos estudar algoritmos mais eficientes.
Para se ordenar uma lista L = (m 1 , m 2 , ...,mn ) por intercalação, divide-se L em duas sublistas L 1 e L 2 , tais que:
L 1 = (m 1 , m 2 , ...,mk ) , L 2 = (mk+1 , mk+2 , ...,mn ) , onde k = (n/2) Em seguida L 1 e L 2 são ordenadas separadamente e são obtidas duas sublistas ordenadas L’ 1 e L’ 2 , de acordo com a estratégia de divisão e conquista. Agora, as soluções parciais L’ 1 e L’ 2 devem ser combinadas para se obter a solução final. Isto pode ser feito intercalando-se os elementos de L’ 1 e L’ 2 da seguinte forma:
seleciona-se o menor elemento entre m ’ 1 e m ’k+1 (em caso de igualdade seleciona-se m ’ 1 , por exemplo), este elemento é retirado da lista à qual pertence e colocado numa lista L’; repete-se a seleção do menor, sendo que agora o elemento é escolhido entre m ’ 2 e m ’k+1 (se o escolhido foi m ’ 1 ) ou entre m ’ 1 e m ’k+2 (se o escolhido foi m’k+1 ), e um segundo elemento é colocado na lista L ’; e este processo de seleção do menor é repetido até que se obtenham n elemento em L’.
Não é difícil observar que a lista resultante estará em ordem crescente, e que toda a intercalação pode ser feita com n-1 comparações e que portanto em tempo cn , onde c é uma constante c>1.
O algoritmo que descrevemos necessita somente da lista a ser ordenada e de uma lista auxiliar interna ao procedimento para armazenar temporariamente a lista durante a intercalação.
objetivo: ordenar uma lista por intercalação de duas sublistas entradas: L (lista), N (tamanho da lista - inteiro) saída: L (lista ordenada crescente) OrdInter (n,L) 1 se N <= 1 então 2 ordinter m (^1) 3 senão 4 k (n/2); 5 L1 ordinter(k, L); 6 L2 ordinter(n-k, L); 7 L Intercala(L1, L2) 8 ordinter L; 9 fim-se;
Rapidez da Ordenação por intercalação
Seja T(n) o tempo de execução do OrdInter para uma entrada de tamanho n. A operação elementar a ser considerada em T(n) será a comparação entre dois elementos mi. Se n = 1, observamos no algoritmo que T(1) = 0. Se n > 1, a execução na linha 5 requer tempo T(n/2) e na linha 6 também T(n/2). Como foi dito acima, a intercalação na linha 7 requer tempo cn, para uma constante c>1. Temos então a formula de recorrência:
desenvolver a intercalação conforme descrito acima