Eda 2

Estruturas de Dados e Algoritmos
Aula 2
José Jasnau Caeiro

j.caeiro@ipbeja.pt
Instituto Politécnico de Beja
2023-2024
1 de 32 Caeiro (Instituto
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 1/
Projeto de Algoritmos
Técnicas de
pr
HáOjet
umaO grande variedade no que se refere ao tipo de técnicas de projeto de algoritmos.
Estudam-se duas com aplicação aos algoritmos de ordenação:
a abordagem incremental ;
a técnica de divisão e conquista .
O algoritmo MERGE-SORT é projetado com o recurso à técnica de divisão e conquista.
Estruturas
Politécnico
de Dados
de Beja)
1 Técnicas
Abordagem Incremental
Divisão e Conquista
2 Merge Sort
Aplicação do Paradigma
Complexidade Computacional- merge
merge sort
Complexidade Computacional
Teorema Principal
Resultado
3 Realização Experimental
Estruturas
Politécnico
de Dados
de Beja)
Técnicas Abordagem Incremental
Abordagem Incremental
POr induçãO
matemática
é a técnica usada no algoritmo INSERTION-SORT;
um elemento de cada vez, designado por key, é incrementalmente colocado, através de
uma iteração em valores sucessivos, no local apropriado;
após todos os elementos terem sido processados, um após o outro, a estrutura de dados
sequencial encontra-se ordenada.
Estruturas
Politécnico
de Dados
de Beja)
Técnicas Divisão e Conquista
Estrutura Geral da
Técnica
DivisãO e
COnquista
muitos algoritmos são recursivos na sua arquitetura;
esta arquitetura conduz à chamada da função que representa o algoritmo pela
própria função;
esta chamada é realizada uma ou mais vezes para tratar de sub-problemas estreitamente
relacionados com o problema;
este tipo de algoritmos seguem uma abordagem típica designada por divisão e conquista;
dividem o problema em vários sub-problemas similares ao problema original mas com
dimensão menor, resolvem os sub-problemas recursivamente e combinam as soluções
resultantes para criar a solução do problema original.
Estruturas
Politécnico
de Dados
de Beja)
Técnicas Divisão e Conquista
Divisão e
Conquista
Os 3
pass
A OS
divisão e conquista envolve 3 passos em cada nível da recursividade
Divisão do problema num certo número de sub-problemas que são instâncias menores do
mesmo problema;
Conquista dos sub-problemas por resolução recursiva. Se os sub-problemas são
suficientemente pequenos então resolvem-se diretamente;
Combinação as soluções dos sub-problemas são agregadas na solução do problema original.
Estruturas
Politécnico
de Dados
de Beja)
Merge Sort Aplicação do Paradigma
Aplicação do Paradigma da Divisão e Conquista
Merge-Sort
O algoritmo MERGE-SORT segue de perto o paradigma da divisão e conquista.
Divisão divide-se a sequência A de n elementos em duas sub-sequências com n/2
elementos cada;
Conquista ordenam-se as duas sub-sequências recursivamente usando o procedimento
MERGE-SORT;
Combinação agregam-se (MERGE) as duas sub-sequências de modo a produzir a sequência
final ordenada.
Estruturas
Politécnico
de Dados
de Beja)
Agregação
COmbinar OS resultadOS
A operação mais crucial do algoritmo MERGE-SORT é a agregação das duas sub-sequências
ordenadas no passo de combinação.
O procedimento de agregação é chamado pelo procedimento auxiliar MERGE (A, p, q, r);
A é uma tabela unidimensional;
p, q e r são índices da tabela
A; p ≤ q < r.
O procedimento assume que as sub-tabelas A[p, . . . , q] e A[q + 1, . . . , r] se encontram
ordenadas.
Agrega estas sub-tabelas para substituir a sub-tabela A[p, . . . , r].
Estruturas
Politécnico
de Dados
de Beja)
merge
Figura: Pseudo código do algoritmo merge.

Estruturas
Politécnico
de Dados
de Beja)
Funcionamento
Merge
a linha 1 calcula a dimensão da sub-tabela A[p, . . . , q], correspondente à parte
esquerda; a linha 2 calcula a dimensão da sub-tabela A[q + 1, . . . , r], correspondente
à parte direita; na linha 3 são criadas as duas sub-tabelas L, com dimensão n1 + 1, e
R com dimensão
n2 + 1;
o ciclo for nas linhas 4 e 5 copia os elementos da sub-tabela A[p, . . . , q] para L[1, . . . , n1];
o ciclo for nas linhas 6 e 7 copia os elementos da sub-tabela A[q + 1, . . . , r] para
R[1, . . . , n2];
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 10 / 32
Funcionamento
Merge (cOnt.)
as linhas 8 e 9 colocam sentinelas (marcadores de fim de processamento) no fim das
tabelas L e R;
as linhas 10 a 17 copiam r − p + 1 vezes o elemento de menor valor escolhido de L ou
R
para a posição adequada de A, ou seja,
se L[i] ≤ R[j] então é copiada para a posição A[k] = L[i];
em caso oposto A[k] = R[j]
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 11 / 32
Passo a Passo
(1)
Figura: Funcionamento passo a passo.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 12 / 32
Passo a Passo
(2)
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 13 / 32
Passo a Passo
(3)
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 14 / 32
Merge Sort Complexidade Computacional- merge
Taxa de crescimentO assintótica dO tempO de

execuçãO
O algoritmo MERGE possui uma ordem de crescimento assintótica estrita temporal
dada por Θ(n);
n = r − p + 1;
as linhas 1 a 3 e 8 a 11 custam um tempo
constante; o ciclo for dura Θ(n1 + n2) = Θ(n);
há n iterações no ciclo entre as linhas 12 a 17, cada uma com custo temporal constante.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 15 / 32
Merge Sort merge sort
merge sort
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 16 / 32
merge sort
A OrdenaçãO
O procedimento MERGE-SORT ordena os elementos na sub-tabela A[p, . . . , r].
se p ≥ r, então a sub-tabela tem no máximo um elemento e está praticamente
ordenada; em alternativa o passo de divisão calcula um índice q que faz uma partição
da tabela A[p, . . . , r] em duas sub-tabelas:
A[p, . . . , q] contendo [n/2| elementos;
A[q + 1, . . . , r] contendo [n/2♩ elementos.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 17 / 32
merge sort
A OrdenaçãO
para ordenar A = ⟨A[1], A[2], . . . , A[n]⟩ realiza-se a chamada inicial de
MERGE-SORT(A, 1, A.length) , A.length = n;
o algoritmo MERGE-SORT agrega sucessivamente sub-tabelas de dimensão
2k, k = 0, . . . , log2(n).
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 18 / 32
Merge Sort Complexidade Computacional
Análise cOm chamadas recursivas

A complexidade computacional num algoritmo com chamadas recursivas pode ser obtida
através duma equação de recorrência
O tempo de execução designa-se por T (n)
Se a dimensão do problema é suficientemente pequena, n ≤ c, para uma certa constante
c, a solução direta leva tempo constante, Θ(1);
Suponha-se que a divisão do problema dá origem a a sub-problemas cada um
com dimensão 1/b da dimensão original;
Leva T (n/b) para resolver um problema de dimensão n/b e portanto
Leva aT (n/b) para resolver a problemas.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 19 / 32
EquaçãO de recOrrência
sendo D(n) o tempo necessário para sub-dividir o problema em sub-problemas
sendo C (n) o tempo necessário para combinar as soluções dos sub-problemas na solução
do problema original,
tem-se a recorrência:
Θ(1) se n ≤ c,
aT (n/b) + D(n) + C (n) caso contrário.
T (n) =
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 20 / 32
Merge-Sort
NO casO dO algOritmO MERGE-SORT cOnsidera-se na análise que
a dimensãO Original da tabela A, é uma pOtência de 2, A.length = 2M ;
Cada passO da divisãO dá Origem a duas sub-tabelas de dimensãO n/2;
A aplicaçãO dO algOritmO MERGE-SORT numa tabela cOm apenas um elementO
leva tempO cOnstante.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 21 / 32
Merge-Sort
QuandO há n > 1 elementOS, O tempO de execuçãO pOde ser divididO em:
Dividir O passO de divisãO calcula O pOntO central da sub-tabela, O que leva tempO
cOnstante, pOrtantO, D(n) = Θ(1);
COnquista ResOlvem-se recursivamente 2 prOblemas, cada um cOm dimensãO n/b = n/2,
O que cOntribui aT (n/b) = 2T (n/2) para O tempO de execuçãO;
COmbinaçãO O prOcedimentO MERGE demOra C (n) = Θ(n), cOmO fOi previamente calculadO.
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 22 / 32
Merge-Sort
ReunindO as expressões para cálculO dO tempO de execuçãO teremOS
Θ(1) se n ≤ 1,
2T (n/2) + Θ(n) se n >
T (n) = 1.
A expressãO definitiva da cOmplexidade cOmputaciOnal Obtida a partir desta equaçãO de
recOrrência é Obtida através da aplicaçãO dO teorema principal, cOnsiderandO Θ(1) = c, Ou
seja,
c se n ≤ 1,
2T (n/2) + nc se n > 1.
T (n) =
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 23 / 32
Merge Sort Teorema Principal
Teorema Principal
Três situações
Sejam a ≥ 1 e b > 1 cOnstantes, f (n) uma funçãO, e T (n) definida sObre um cOnjuntO
de inteirOS nãO-negativOS pela recOrrência
T (n) = aT (n/b) + f (n),
EntãO T (n) assume OS Seguintes valOres assintóticOS:

1 Se f (n) = O(nlogb a−є) para uma cOnstante ϵ > 0, entãO T (n) = Θ(nlogb a ).
2 Se f (n) = O(nlogb a ), entãO T (n) = Θ(nlogb a log(n)).
3 Se f (n) = O(nlogb a+є), para uma cOnstante ϵ > 0, e se af (n/b) ≤ cf (n) para alguma
cOnstante c < 1 e valOres de n suficientemente elevadOS, entãO T (n) = Θ(f (n)).
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 24 / 32
Merge Sort Resultado
Aplicação do Teorema Principal

Merge-Sort
AplicandO O teorema aO algOritmO MERGE-SORT tem-se
principal
T (n) = 2T (n/2) + Θ(n),
Ou seja, a = 2, b = 2, f (n) = Θ(n)
Θ(n logb a) = Θ(n log2 2) = Θ(n1) = Θ(n)
e entãO verificam-se as cOndições dO casO 2 dO teOrema principal e a Ordem de crescimentO, nO

piOr cenáriO, é dada pOr
Θ(nlogb a log(n)) = Θ(nlog2 2 log(n)) = Θ(n log(n)) .
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 25 / 32
Merge Sort Resultado
Representação Gráfica de Tempos de

Execução
Figura: TempOS de execuçãO para várias Ordens de cOmplexidade cOmputaciOnal.

Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 26 / 32
Realização Experimental
Uma Realização do Algoritmo

merge
% -*- matlab-mode -*-
function A = mymerge (A, p, q, r)
n1 = q - p + 1; n2 = r - q;
L = zeros(1, n1+1); R = zeros(1, n2+1);
for i = 1:n1 L(i) = A(p + i - 1); end
for j = 1:n2 R(j) = A(q + j); end
L(n1+1) = intmax('int32'); R(n2+1) = intmax('int32');
i = 1; j = 1;
for k = p:r
if( L(i) <= R(j) )
A(k) = L(i); i = i + 1;
else
A(k) = R(j); j = j + 1;
end
e
27 de 3 2 Caeiro (Instituto Politécnico
Estruturas de Beja)
de Dados e Algoritmos 2023-2024 27 / 32
Uma Realização do Algoritmo

merge
% -*- matlab-mode -*-
% ---------------------- x x x x x x x x
% 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
A =[2,3,4,1,6,7,8,1, 2, 4, 5, 7, 1, 2, 3, 6, 7,8];
p = 9;
q = 12;
r = 16;
%A(p:r)
A
A = mymerge(A,p,q,r);
A
%A(p:r)
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 28 / 32
Uma Realização do Algoritmo merge em Kotlin
import kotlin.math.*
class MergeSort(var A: IntArray){
fun merge(p: Int, q: Int, r: Int) {
val n1 = q-p+1
val n2 = r-q
val L = IntArray(n1+1)
val R = IntArray(n2+1)
for(i in 0..n1-1) L[i] = A[p+i] // 1..n1
for(j in 0..n2-1) R[j] = A[q+j+1] // 1..n2
L[n1] = Int.MAX_VALUE // n1+1
R[n2] = Int.MAX_VALUE // n2+1
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 29 / 32
var i = 0 // 1
var j = 0 // 1
for(k in p..r){
if( L[i] <= R[j] ){
A[k] = L[i]
i++
} else {
A[k] = R[j]
j++
}
}
} // end fun merge
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 30 / 32
fun mergeSort(p: Int, r: Int) {

if( p < r ){
val q: Int = floor((p+r)/2.0).toInt()
mergeSort(p, q)
mergeSort(q+1, r)
merge(p, q, r)
}
} // end fun mergeSort
} // end class MergeSort
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 31 / 32
import kotlin.random.*
fun main() {
val A = IntArray(10) { Random.nextInt(0, 100)}
val mergeSort = MergeSort(A)
val p = 0 // 1
val r = A.size-1 // A.size
mergeSort.mergeSort(p, r)
}
Estruturas
Politécnico
de Dados
de Beja)
e Algoritmos 2023-2024 32 / 32

Eda 2

Enviado por

Dados do documento

Descrição original:

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Eda 2

Enviado por

Direitos autorais:

Formatos disponíveis

Estruturas de Dados e Algoritmos

José Jasnau Caeiro

Instituto Politécnico de Beja

Aplicação do Paradigma da Divisão e Conquista

Figura: Pseudo código do algoritmo merge.

Figura: Funcionamento passo a passo.

Figura: Funcionamento passo a passo.

Figura: Funcionamento passo a passo.

Taxa de crescimentO assintótica dO tempO de

Análise cOm chamadas recursivas

T (n) = aT (n/b) + f (n),

EntãO T (n) assume OS Seguintes valOres assintóticOS:

Aplicação do Teorema Principal

Ou seja, a = 2, b = 2, f (n) = Θ(n)

Θ(n logb a) = Θ(n log2 2) = Θ(n1) = Θ(n)

e entãO verificam-se as cOndições dO casO 2 dO teOrema principal e a Ordem de crescimentO, nO

Θ(nlogb a log(n)) = Θ(nlog2 2 log(n)) = Θ(n log(n)) .

Representação Gráfica de Tempos de

Figura: TempOS de execuçãO para várias Ordens de cOmplexidade cOmputaciOnal.

Uma Realização do Algoritmo

Uma Realização do Algoritmo

Uma Realização do Algoritmo merge em Kotlin

Uma Realização do Algoritmo merge em Kotlin

Uma Realização do Algoritmo merge em Kotlin

fun mergeSort(p: Int, r: Int) {

Uma Realização do Algoritmo merge em Kotlin

Você também pode gostar