Você está na página 1de 30


▶ Tail recursion

▶ Memoization


Algorithm Power(x, n){
if n = 0 then
return 1
if n is odd then
y := Power(x, (n - 1)/2)
return x * y * y
else
y := Power(x, n/2)
return y * y
}

• A recursão diz-se linear se uma operação é composta por uma sequência de acções
seguida pela mesma operação (para uma instância mais simples)
Algorithm Power(x, n){
if n = 0 then
return 1
if n is odd then
y := Power(x, (n - 1)/2)
return x * y * y
else
y := Power(x, n/2)
return y * y
}

• A análise do tempo de execução do algoritmo pode fazer-se recorrendo a traços de


execução.
• O número de chamadas recursivas é 1+log n, donde T(n) é O(log n)

O(n)
• input



• mid
(min+max)/2 min + (max-min)/2

overflows
Algorithm binarySearch(X,x,min,max){
if min > max then
return false
mid := min + (max-min)/2
if x = X[mid] then
return true
if x < X[mid] then
return binarySearch(X,x,min,mid-1)
else
return binarySearch(X,x,mid+1,max)
}
Algorithm binarySearch(X,x,min,max){
if min > max then
return false
mid := min + (max-min)/2
if x = X[mid] then
return true
if x < X[mid] then
return binarySearch(X,x,min,mid-1)
else
return binarySearch(X,x,mid+1,max)
}

binarySearch(X,x,0,max)
1+log n T(n) é O(log n)

return

Java Method Stack
)










tail recursion


tail recursion (

– tail recursive
call stack
Algorithm ReverseArray(A,
Algorithm ReverseArray(A, i, j){ i, j){
versão tail recursive
if
if i<ji<j
then then
swap
swapA[i] and
A[i] and A[j]A[j]
ReverseArray(A,
ReverseArray(A, i+1,i+1,
j-1) j-1)
return
return
}}

versão iterativa ?
Algorithm ReverseArray(A,
Algorithm ReverseArray(A, i, j){ i, j){
versão tail recursive
if
if i<ji<j
then then
swap
swapA[i] and
A[i] and A[j]A[j]
ReverseArray(A,
ReverseArray(A, i+1,i+1,
j-1) j-1)
return
return
}}

Algorithm
Algorithm ItReverseArray(A, i, j){
ItReverseArray(A, i, j){
versão iterativa
while i<ji<j
while
swapA[i]
swap A[i] and A[j]A[j]
and
i i :=
:=i+1
i+1
j j :=
:=j-1j-1
return
return
}}
Algorithm
Algorithm Sum(A,Sum(A,
n){ n){
if n>0
if n>0 then then
return
return A[n-1]+Sum(A,
A[n-1]+Sum(A, n-1) n-1)
return
return 0 0
}}

versão tail recursive ?


Algorithm Sum(A, n){
if n>0 then
return A[n-1]+Sum(A, n-1)
return 0
}
versão tail recursive
Algorithm SumAux(A, n, acc){
if n>0 then
return SumAux(A, n-1, acc+A[n-1])

return acc
}
Algorithm Sum(A, n){
return SumAux(A, n, 0)
}
Algorithm SumAux(A, n, acc){
if n>0 then
return SumAux(A, n-1, acc+A[n-1])

return acc
}

Algorithm Sum(A, n){


return SumAux(A, n, 0)
versão iterativa
}
Algorithm ItSum(A, n){
acc := 0
while n>0
acc := acc+A[n-1]
n := n-1
return acc
}


Algorithm Fib(n){
if n = 0 then
return 0
if n = 1 then
return 1
return Fib(n-1)+Fib(n-2)
}

Algorithm Fib(n){
if n = 0 then
return 0
if n = 1 then
return 1
return Fib(n-1)+Fib(n-2)
}


• ϴφ
onde φ= √ ≈1.618 é o número de ouro, ou proporção áurea



Algorithm FibMem(n, mem){
if mem[n] = -1
if n = 0 then
mem[n] := 0
else if n = 1 then
mem[n] := 1
else
mem[n] := FibMem(n-1,mem) + FibMem(n-2,mem)
return mem[n]
}

Algorithm Fib(n){
inicializar mem com uma sequencia de (n+1) -1’s
return FibMem(n, mem)
}
• ,









– master method
– iteration method