Autoria: Carlos Eduardo Cayres | 4

(VWUXWXUDGH'DGRV

Autoria: Carlos Eduardo Cayres | 4

o

_semestre

Tema 02

Recursividade

7HPD

Recursividade

Autoria: Carlos Eduardo Cayres

Como citar esse documento:

CAYRES, Carlos Eduardo. Estrutura de Dados: Recursividade. Valinhos: Anhanguera Educacional, 2014.

Índice

‹ $QKDQJXHUD (GXFDFLRQDO 3URLELGD D UHSURGXomR ¿QDO RX SDUFLDO SRU TXDOTXHU PHLR GH LPSUHVVmR HP IRUPD LGrQWLFD UHVXPLGD RX PRGL¿FDGD HP OtQJXD SRUWXJXHVDRXTXDOTXHURXWURLGLRPD

Pág. 17

Pág. 18 Pág. 19

Pág. 18 Pág. 15 Pág. 13

ACOMPANHE

_NA

WEB

Pág. 3

CONVITE

À

LEITURA

Recursividade

Introdução ao conceito de Funções e Recursividade em C

Antes de partir para recursividade propriamente dita vamos fazer uma revisão sobre funções em C para que possamos compreender melhor o paradigma da recursividade, já que recursividade está diretamente relacionada ao conceito de função e sua implementação.

O presente tema irá abordar um recurso muito utilizado em linguagens de programação na solução de alguns SUREOHPDVFRPSXWDFLRQDLVDUHFXUVLYLGDGHTXHSRGHVHUFODVVL¿FDGDFRPRXPDSRGHURVDHVWUXWXUDGHSURJUDPDomR de difícil compreensão para iniciantes em programação.

Antes de partir para recursividade propriamente dita vamos fazer uma revisão sobre funções em C para que possamos compreender melhor o paradigma da recursividade, já que recursividade está diretamente relacionada ao conceito de função e sua implementação.

Iremos apresentar exemplos de programas recursivos e analisar vantagens e/ou desvantagens das implementações recursivas em relação às iterativas.

'H¿QLUHPRVUHFXUVLYLGDGHLQWURGX]LUHPRVVHXXVRHP&HDSUHVHQWDUHPRVYiULRVH[HPSORV([DPLQDUHPRVWDPEpP uma implementação iterativa e recursiva para solução de fatoriais.

CONVITE

_À

LEITURA

R

i id d

p ç p ç

POR

_DENTRO

DO

_TEMA

Funções em C

)XQo}HVVmRWUHFKRVGHSURJUDPDTXHUHDOL]DPDWLYLGDGHVEHPHVSHFt¿FDVHPGHWHUPLQDGRPRPHQWRGDH[HFXomR Todo programa escrito na linguagem de programação C possui, no mínimo, uma função chamada de função principal do SURJUDPDDIXQomRPDLQTXHpUHVSRQViYHOSHODH[HFXomRGRSURJUDPD

(PDOJXQVFDVRVDVIXQo}HVUHFHEHPYDORUHVGRSURJUDPDSULQFLSDOSDUDSRGHUHPWUDEDOKDU(VWHVYDORUHVVmRFKDPDGRV de parâmetros.

2XWURHOHPHQWRLPSRUWDQWHpRUHWRUQRGDIXQomRYDORUTXHDIXQomRSURGX]HPDQGDGHYROWDDRSURJUDPDSULQFLSDORX para outra função.

Exemplo 1:3URJUDPDHP&TXHUHFHEDGXDVQRWDVFDOFXOHHPRVWUHDPpGLDDULWPpWLFDXVDQGRXPDIXQomR$IXQomR não receberá parâmetros e não retornará nenhum valor ao programa principal.

#include <iostream> #include <stdio.h> void calc_media(); int main() { calc_media(); } void calc_media(){ ÀRDWQRWDQRWDPHGLD printf( “Digite a primeira nota: “); VFDQI³G´ QRWD

printf( “Digite a segunda nota: “); VFDQI³G´ QRWD

PHGLD QRWDQRWD SULQWI³0pGLD G³PHGLD V\VWHP³3$86(´

}

$RGHVHQYROYHUSURJUDPDVHP&XWLOL]DQGRIXQo}HVGH¿QLGDVSHORXVXiULRFRPRQRH[HPSORDQWHULRUHVWDVSRGHP VHUHVFULWDVDQWHVRXGHSRLVGDIXQomRPDLQ6HIRUHVFULWDGHSRLVGDIXQomRPDLQpSUHFLVRDGLFLRQDUXPDLQVWUXomR para que o compilador possa interpretar a função quando estiver percorrendo linearmente todas as linhas do programa. Informações como, a quantidade e o tipo de parâmetros, se tem ou não retorno de valor e qual o seu tipo. Tal instrução GHYHVHUDFUHVFHQWDGDDQWHVGDIXQomRPDLQHpFKDPDGDGHSURWyWLSRGDIXQomR

Passagem de parâmetros

Cada função pode receber vários valores chamados de parâmetros, e pode devolver com retorno um valor. Dessa IRUPDTXDQGRVHHVSHFL¿FDXPDIXQomRGHYHVHGHL[DUFODURTXDOVHUiRWLSRGHUHWRUQRHTXDLVRVSDUkPHWURVQHFHVViULRV para que à execução da função.

Exemplo 1:

LQWVRPDBQXPLQWQLQWQ {

int soma;

VRPD QQ

return soma; }

1R H[HPSOR REVHUYDVH TXH IRL UHDOL]DGD D VRPD GH GRLV YDORUHV LQWHLURV Q H Q TXH IRUDP SDVVDGRV FRPR SDUkPHWURVSDUDDIXQomR2UHVXOWDGRGHVWDVRPDDUPD]HQDGRQDYDULiYHOVRPDTXHHPVHJXLGDpGHYROYLGRDRSRQWR HPTXHDIXQomRIRLFKDPDGDGXUDQWHDH[HFXomRGRSURJUDPD,VWRVyIRLSRVVtYHOSRUTXHDIXQomRHVWDYDSUHSDUDGD SDUDWUDWDUHVWHVYDORUHVFRQIRUPHHVSHFL¿FDGRQDSULPHLUDOLQKDGDIXQomRLQWVRPDBQXPLQWQLQWQ

Exemplo 2:

ÀRDWGLYLGLUBQXPLQWGLYLGHQGRLQWGLYLGRU {

ÀRDWUHV

res = dividendo / divisor; return res;

}

1RH[HPSORIRLUHDOL]DGDXPDRSHUDomRGHGLYLVmR3RGHVHREVHUYDUTXHDIXQomRUHFHEHXGRLVYDORUHVLQWHLURVSDUD proceder a operação. É sabido que o resultado de uma divisão pode gerar valores reais, por isso, o resultado teve que VHUDUPD]HQDGRHPXPDYDULiYHOGRWLSRÀRDWTXHDSyVUHFHEHURUHVXOWDGRGDGLYLVmRIRLGHYROYLGRDRSRQWRHPTXH a função foi chamada na execução do programa. Como o resultado da divisão pode gerar um número real a função GLYLGLUBQXPIRLGH¿QLGDFRPRVHQGRÀRDW

Exemplo 3:

YRLGPXOWLSOLFDUBQXPÀRDWPXOWLSOLFDQGRÀRDWPXOWLSOLFDGRU {

ÀRDWUHV

res = multiplicando * multiplicador;

SULQWI³?Q2UHVXOWDGRGDPXOWLSOLFDomRp G³UHV

V\VWHP³3$86(´

}

No exemplo 3 podemos observar outra variação da utilização da função. Neste caso a função recebeu dois parâmetros GRWLSRÀRDWSDUDFDOFXODUDPXOWLSOLFDomR2UHVXOWDGRGDRSHUDomRGHPXOWLSOLFDomRIRLPRVWUDGRGHQWURGDSUySULD IXQomRVHQGRDVVLPDIXQomRQmRWHPUHWRUQRHIRLGH¿QLGDFRPRYRLG

Passagem de parâmetros por valor

3DVVDJHPGHSDUkPHWURVSRUYDORUVLJQL¿FDTXHSDUDDH[HFXomRGDIXQomRVHUmRJHUDGDVFySLDVGRVYDORUHVGH cada um dos parâmetros. Como exemplo, observe o programa abaixo:

LQFOXGHLRVWUHDP! LQFOXGHVWGLRK! LQWVRPDBGREURLQWDLQWE LQWPDLQ

^LQW[\UHV

SULQWI³?Q'LJLWHRSULPHLURQ~PHUR³

VFDQI³G´ [

SULQWI³?Q'LJLWHRVHJXQGRQ~PHUR³ VFDQI³G´ \

UHV VRPDBGREUR[\

SULQWI³?Q$VRPDGRGREURGRVQ~PHURVGHGpG´[\UHV V\VWHP³3$86(´`

LQWVRPDBGREURLQWDLQWE ^LQWVRPD

D D E E VRPD DE UHWXUQVRPD `

(VWDPRVVXSRQGRTXHRVYDORUHVDUPD]HQDGRVQDVYDULiYHLV[H\DWUDYpVGDH[HFXomRGDVOLQKDVHGRSURJUDPD DQWHULRUIRUDPUHVSHFWLYDPHQWHH4XDQGRDOLQKDpH[HFXWDGDHVWHVYDORUHVVmRFRSLDGRVSDUDDVYDULiYHLVDH ESHUWHQFHQWHVjIXQomRVRPDBGREUR'HSRLVGLVVRRVYDORUHVGHDHEVmRPXOWLSOLFDGRVSRUHGHSRLVpUHDOL]DGD DVRPD2UHVXOWDGRGHVWDVRPDpGHYROYLGRjIXQomRPDLQDWUDYpVGDH[HFXomRGDOLQKDRQGHRYDORUFDOFXODGR UHFDLVREUHDYDULiYHOUHV1RPRPHQWRHPTXHDIXQomRVRPDBGREURFKHJDDR¿PDVYDULiYHLVDEHVRPDVmR GHVWUXtGDVHSRUWDQWRDVDOWHUDo}HVUHDOL]DGDVDWUDYpVGDVPXOWLSOLFDo}HVSRUVmRSHUGLGDV

Passagem de parâmetros por referência

Na passagem de parâmetros por referência os parâmetros passados para uma função fazem referência a endereços GHPHPyULDDORFDGRVSDUDYDULiYHLV,VVRVLJQL¿FDTXHWRGDYH]TXHIRUSUHFLVRDFHVVDUGHWHUPLQDGRYDORUGHXPD YDULiYHOVySRGHUiVHUIHLWRUHIHUHQFLDQGRVHXHQGHUHoR

POR

_DENTRO

DO

_TEMA

LQFOXGHLRVWUHDP!

LQFOXGHVWGLRK!

LQWVRPDBGREURLQWDLQWE LQWPDLQ

^LQW[\UHV

SULQWI³?Q'LJLWHRSULPHLURQ~PHUR³ VFDQI³G´ [

SULQWI³?Q'LJLWHRVHJXQGRQ~PHUR³ VFDQI´G´ \

UHV VRPDBGREUR [ \

SULQWI³?Q$VRPDGRVQ~PHURVGHGpG´[\UHV V\VWHP³3$86(´`

LQWVRPDBGREURLQWDLQWE ^LQWVRPD

D D E E VRPD DE UHWXUQVRPD`

Nas linhas 7 e 9 são lidos, respectivamente, os valores para as variáveis x e y (como exemplo, estamos supondo que IRUDPGLJLWDGRVRVYDORUHVH(QWUHWDQWRTXDQGRDIXQomRVRPDBGREURpFKDPDGDQDOLQKDVmRSDVVDGRVFRPR SDUkPHWURVSDUDDIXQomRRVHQGHUHoRVGHPHPyULDRFXSDGRVSHODVYDULiYHLV[H\LVWRpIHLWRDWUDYpVGRRSHUDGRU TXHREWpPRHQGHUHoRGHPHPyULDGHXPDYDULiYHORXVHMDFRQIRUPHQRVVRH[HPSORRVYDORUHVHQGHUHoR RFXSDGRSRU[HHQGHUHoRRFXSDGRSRU\'HVVDIRUPDRVYDORUHVTXHUHFDHPVREUHDVYDULiYHLVDHEGD IXQomRVmRUHVSHFWLYDPHQWHHLVWRpFRUUHWRXPDYH]TXHDHEVmRSRQWHLURVSDUDLQW

1DVOLQKDVHRVYDORUHVHVmRPXOWLSOLFDGRVSRU1HVWHPRPHQWRRFRUUHD³UHIHUrQFLD´DRVHQGHUHoRVGH PHPyULDHSDUDTXHVHMDPREWLGRVRVYDORUHVLQLFLDLVHDSyVDUHDOL]DomRGDVPXOWLSOLFDo}HVVHMDPDOWHUDGRV RVYDORUHVDOWHUDGRVHDVVLPQRHQGHUHoRSDVVDPRVDWHURYDORUHQRHQGHUHoRSDVVDPRVDWHURYDORU 1DOLQKDpUHDOL]DGDDVRPDGRVYDORUHVTXHHVWmRQRVHQGHUHoRVHVSHFL¿FDGRVSRUDHETXHMiIRUDPPXOWLSOLFDGRV SRU

)LQDOPHQWHQDOLQKDRUHVXOWDGRGDVRPDpGHYROYLGRjIXQomRPDLQUHFDLQGRVREUHDYDULiYHOUHVHHQFHUUDQGRD IXQomRVRPDBGREUR4XDQGRDIXQomRVRPDBGREURFKHJDDR¿PDVYDULiYHLVDEHUHVVmRGHVWUXtGDVHQWUHWDQWRDV alterações decorrentes das multiplicações feitas são mantidas, pois não geraram duplicatas de valores, mas sim, a todo PRPHQWR¿]HUDPUHIHUrQFLDDHQGHUHoRVGHPHPyULDTXHHVWDYDPIRUDGDiUHDGHVWLQDGDjIXQomR

(PPXLWDVOLQJXDJHQVGHSURJUDPDomRYHWRUHVHPDWUL]HVVmRSDVVDGRVSDUDIXQo}HVFRPRRVGHPDLVWLSRVGHGDGRV SRUYDORUHSRUUHIHUrQFLD(QWUHWDQWRTXDQGRDOLQJXDJHP&pXWLOL]DGDSRGHVHDSHQDVSDVViORVSRUUHIHUrQFLDRX seja, a função recebe apenas o endereço da primeira posição do vetor ou da matriz.

Exemplo 1:

LQWYHW>@

exemplo(&vet[0]);RHQGHUHoRGHPHPyULDRFXSDGRSHODSRVLomRGRYHWRUpSDVVDGRSDUDDIXQomRH[HPSOR exemplo(vet);TXDQGRVHXWLOL]DDSHQDVRQRPHGRYHWRUVHPFROFKHWHVHtQGLFHVLJQL¿FDTXHWDPEpPHVWDPRV

SHJDQGRRHQGHUHoRGHPHPyULDRFXSDGRSHODSRVLomRGRYHWRU

void exemplo(int v[]) ou void exemplo(int *x)

{

//linhas de comando

}

Exemplo 2:

ÀRDWPDW>@>@

exemplo2 (&mat[0][0]); exemplo2 (mat);

YRLGH[HPSORÀRDWD>@>@

{

//linhas de comando

}

Recursividade em C

8P REMHWR p GHQRPLQDGRrecursivo VH HOH p SDUFLDOPHQWH GH¿QLGR HP WHUPRV GHOH PHVPR$ UHFXUVLYLGDGH p

HQFRQWUDGDSULQFLSDOPHQWHQDPDWHPiWLFDSRUpPHVWiSUHVHQWHHPYiULDVVLWXDo}HVGRQRVVRFRWLGLDQR

Na programação, a recursividade segue o mesmo conceito da matemática: dividir o problema em instâncias menores VHPDOWHUDUDVFDUDFWHUtVWLFDVGRSUREOHPDSDUDIDFLOLWDUDREWHQomRGDUHVSRVWD8PDIXQomRpFRQVLGHUDGDUHFXUVLYD VHHODFRQWpPXPDFKDPDGDDVLPHVPD'HYHVHFRQVLGHUDURPRPHQWRHPTXHDUHFXUVLYLGDGHWHUPLQDSRLVFDVR LVWRQmRVHMDIHLWRRSURJUDPD¿FDUiHPH[HFXomRLQ¿QLWDPHQWHORRSLQ¿QLWRDWpHVJRWDURVUHFXUVRVGLVSRQtYHLVQR computador (que irá travar).

Como exemplo de problema que pode ser resolvido recursivamente podemos citar o cálculo de um fatorial. Para realizar o cálculo do fatorial de um número (N) algumas regras precisam ser seguidas:

VH1 RX1 HQWmRRIDWRULDO1

VH1!HQWmRIDWRULDO1 IDWRULDO1IDWRULDO1 ou seja, o valor do fatorial do número 4 pode ser obtido assim:

Fatorial(4) = 4 * Fatorial(3)

)DWRULDO )DWRULDO

)DWRULDO )DWRULDO

)DWRULDO

2EVHUYHTXHRIDWRULDOGHIRLREWLGRDWUDYpVGRFiOFXORGRIDWRULDOGHTXHIRLREWLGRDWUDYpVGRFiOFXORGRIDWRULDOGH HDVVLPSRUGLDQWHDWpFKHJDUHPSRLVRYDORUGRIDWRULDOGHpREWLGRGLUHWDPHQWH

A função fatorial

&RQIRUPH7HQHQEDXPQDPDWHPiWLFDYiULRVREMHWRVVmRGH¿QLGRVDSUHVHQWDQGRVHXPSURFHVVRTXHRVSURGX] Por exemplo pGH¿QLGRFRPRDUD]mRHQWUHDFLUFXQIHUrQFLDGHXPFtUFXORHVHXGLkPHWUR,VVRHTXLYDOHDR seguinte conjunto de instruções: obter a circunferência de um círculo e seu diâmetro, dividir o primeiro pelo último e chamar o resultado de (YLGHQWHPHQWHRSURFHVVRHVSHFL¿FDGRSUHFLVDWHUPLQDUFRPXPUHVXOWDGRGH¿QLGR 7(1(1%$80/$1*6$0$8*(167(,1OS

$IXQomRIDWRULDOpFRQVLGHUDGDXPH[HPSORGHGH¿QLomRHVSHFL¿FDGDSRUXPSURFHVVRTXHGHVHPSHQKDXP SDSHOLPSRUWDQWHQDPDWHPiWLFDHQDHVWDWtVWLFD2IDWRULDOGHXPQ~PHURLQWHLURSRVLWLYRQpGH¿QLGRFRPRR SURGXWRGHWRGRVRVLQWHLURVHQWUHQH3RUH[HPSORRIDWRULDOGHpLJXDOD 7(1(1%$80 /$1*6$0$8*(167(,1OS

7HPRVWDPEpPDGH¿QLomRGRIDWRULDOGH]HURTXHp2SRQWRGHH[FODPDomRpRVtPERORXWLOL]DGRSDUDLQGLFDU IXQomRIDWRULDO$GH¿QLomRGDIXQomRIDWRULDOSRGHVHUHVFULWDGHVVDIRUPD

Q VHQ

Q QQQVHQ!

1DUHSUHVHQWDomRDFLPDRVWUrVSRQWRVVLJQL¿FDPDDEUHYLDWXUDSDUDDVHTXrQFLDGRVQ~PHURVH[LVWHQWHVHQWUHQH PXOWLSOLFDGRV6HQmRTXLVHUPRVDEUHYLDUDGH¿QLomRGHQWHPRVTXHHVFUHYHUXPDIyUPXODSDUDQUHSUHVHQWDQGR VHSDUDGDPHQWHFDGDYDORUGHQ

O

POR

_DENTRO

DO

_TEMA

(YLGHQWHPHQWHQmRHVSHUDPRVOLVWDUXPDIyUPXODSDUDRIDWRULDOGHFDGDLQWHLUR3DUDHYLWDUTXDOTXHUDEUHYLDWXUDH XPFRQMXQWRLQ¿QLWRGHGH¿QLo}HVHDLQGDDVVLPGH¿QLUDIXQomRSUHFLVDPHQWHSRGHPRVDSUHVHQWDUXPDOJRULWPR TXHDFHLWHXPLQWHLURQHUHWRUQHRYDORUGHQ7(1(1%$80/$1*6$0$8*(167(,1OS

SURG

IRU[ Q[![ prod *= x;

return(prod);

2WUHFKRGHSURJUDPDDFLPDSUHFLVDGDUHSHWLomRGHGHWHUPLQDGRSURFHVVRDWpTXHXPDFRQGLomRVHMDVDWLVIHLWDWDO

SURJUDPDpFODVVL¿FDGRFRPRiterativo.

Um algoritmo pode ser considerado um programa para uma máquina “ideal”, sem quaisquer limitações práticas GHXPFRPSXWDGRUUHDOHSRUWDQWRSRGHVHUXVDGRSDUDGH¿QLUXPDIXQomRPDWHPiWLFD(QWUHWDQWRXPDIXQomR HP&QmRVHUYHFRPRGH¿QLomRPDWHPiWLFDGDIXQomRIDWRULDOSRU FDXVDGHOLPLWDo}HVFRPRDSUHFLVmRHR WDPDQKR¿QLWRGHXPDPiTXLQDUHDO7(1(1%$80/$1*6$0$8*(167(,1OS

2SURJUDPDDEDL[RGHPRQVWUDXPHVWUXWXUDUHFXUVLYDSDUDFDOFXODURIDWRULDOGHXPQ~PHURLQWHLURTXDOTXHUGH¿QLGR FRPRQ

LIQ

IDW

3 else {

[ Q

DFKHRYDORUGH[&KDPHRGH\

6 fat = n * y;

`¿PHOVH

(YLGHQWHPHQWHDFKDYHGRDOJRULWPRpDOLQKDRQGHVRPRVVROLFLWDGRVD³DFKDURYDORUGH[´,VWRH[LJHD UHH[HFXomRGRDOJRULWPRFRPDHQWUDGD[SRUTXHRPpWRGRSDUDFRPSXWDUDIXQomRIDWRULDOpRSUySULRDOJRULWPR 3DUDYHUL¿FDUVHRDOJRULWPRRFDVLRQDOPHQWHSiUDREVHUYHTXHQRLQtFLRGDOLQKD[pLJXDODQ&DGDYH]TXH o algoritmo for executado, sua entrada será um a menos que na vez anterior, para que (como a entrada n original HUDXPLQWHLURQmRQHJDWLYRVHMDHYHQWXDOPHQWHDHQWUDGDGR DOJRULWPR1HVVHSRQWRRDOJRULWPRDSHQDV UHWRUQD(VVHYDORUpUHWRUQDGRjOLQKDTXHVROLFLWRXDDYDOLDomRGH$PXOWLSOLFDomRGH\LJXDODSRUQ LJXDODpH[HFXWDGDHRUHVXOWDGRpUHWRUQDGR(VVDVHTXrQFLDGHPXOWLSOLFDo}HVHUHWRUQRVSURVVHJXHDWpTXH RQRULJLQDOVHMDDYDOLDGR7(1(1%$80/$1*6$0$8*(167(,1OS

1DDYDOLDomRGDIXQomRIDWRULDO¿FDHYLGHQWHTXHRPpWRGRLQWHUDWLYRpPDLVVLPSOHVHUiSLGR2PpWRGRUHFXUVLYRIRL PRVWUDGRVHPDLQWHQomRGHDSUHVHQWDUXPDIRUPDPDLVH¿FLHQWHGHUHVROYHURSUREOHPDGRIDWRULDOPDVVLPFRPRXP exemplo simples para entendimento da recursividade.

Empilhamento das Chamadas

$QWHVGRSURJUDPDGHVYLDURFXUVRGDH[HFXomRSDUDXPDIXQomRRHQGHUHoRGHUHWRUQRpDUPD]HQDGRQDSLOKD GHH[HFXomR4XDQGRDIXQomRFKHJDUDR¿PRSURJUDPDUHWRUQDUiH[DWDPHQWHSDUDHVWHHQGHUHoRTXHHQWmRVHUi apagado da pilha de execução.

Importante: nem todos os problemas podem ser resolvidos de forma recursiva, cabendo apenas a solução interativa. (QWUHWDQWRWRGRVRVSURJUDPDVUHFXUVLYRVSRGHPVHUUHVROYLGRVLWHUDWLYDPHQWH

Recursividade em C

• 4XDQGR XP PpWRGR UHFXUVLYR p FKDPDGR SDUD UHVROYHU DOJXP SUREOHPD QD YHUGDGH R

PpWRGRpFDSD]GHUHVROYHUDSHQDVRVFDVRVPDLVVLPSOHVVRXRVFDVRVEiVLFRV6H DFKDPDGDGRPpWRGRIRUGHXPPpWRGREiVLFRRPpWRGRUHWRUQDRFDVREDVH6HRPpWRGR IRUFKDPDGRFRPXPSUREOHPDPDLVFRPSOH[RHPJHUDORPpWRGRGLYLGHRSURJUDPDHPGXDV SDUWHVFRQFHLWXDLV±XPDSDUWHTXHRPpWRGRVDEHFRPRID]HUHDRXWUDTXHRPpWRGRQmRVDEH

Disponível em: <KWWSOLQJXDJHPFFRPEUUHFXUVLYLGDGHHPF>$FHVVRHPDJR

(QWUHWDQWRWRGRVRVSURJUDPDVUHFXUVLYRVSRGHPVHUUHVROYLGRVLWHUDWLYDPHQWH

ACOMPANHE

_NA

WEB

ACOMPANHE

_NA

WEB

ACOMPANHE

_NA

WEB

Recursividade em Linguagem C

• $ IXQomR UHFXUVLYD p XP UHFXUVR TXH GHWHUPLQDGDV OLQJXDJHQV GH SURJUDPDomR WHP TXH

SHUPLWHH[HFXWiODVDVLPHVPDVRXVHMDGHQWURGHXPFyGLJRWHPDFDSDFLGDGHGHFKDPDU XP³VXEFyGLJR´SDUDVHUH[HFXWDGR

Disponível em: <KWWSSWVOLGHVKDUHQHWOHRROLPDUHFXUVLYLGDGHHPOLQJXDJHPF>$FHVVRHPDJR

Estrutura de Dados I - Aula1 – Parte 1 Recursividade

• A ideia de recursividade no traz a noção de ações que se repetem diversas vezes, muitas YH]HVFRPREMHWLYRVEHPGH¿QLGRV

Instruções:

Agora, chegou a sua vez de exercitar seu aprendizado. A seguir, você encontrará algumas questões de múltipla

HVFROKDHGLVVHUWDWLYDV/HLDFXLGDGRVDPHQWHRVHQXQFLDGRVHDWHQWHVHSDUDRTXHHVWiVHQGRSHGLGR

AGORA

_É

A

_SUA

VEZ

Questão 1

&RPRLQWXLWRGHYHUL¿FDUDVKDELOLGDGHVGHSURJUDPDomRDGTXLULGDVDWpDJRUDDDWLYLGDGHSURSRVWDpDVROXomRGHXPSUREOHPD simples utilizando os recursos de programação estudados. Tais conhecimentos são extremamente necessários na sequência dos conteúdos, pois teremos muitos exemplos e exercícios baseados na linguagem C.

Problema proposto: Implementar um programa em C que receba o número de peças vendidas por cada vendedor de uma de WHUPLQDGDORMDGHDXWRSHoDV2Q~PHURGHSHoDVYHQGLGDVGHYHUiVHUDUPD]HQDGRHPXPYHWRU'HYHVHUHFHEHUHDUPD]HQDU HPXPVHJXQGRYHWRURYDORUGDFDGDSHoDYHQGLGD1DORMDWUDEDOKDDWXDOPHQWHYHQGHGRUHVHFDGDYHQGHGRUpUHVSRQViYHO SRUYHQGHUDSHQDVXPWLSRGHSHoD&RPRUHVXOWDGRRSURJUDPDGHYHUiDSUHVHQWDUDTXDQWLGDGHWRWDOGHSHoDVYHQGLGDVSHOR YHQGHGRUHVDOpPGHFDOFXODUHPRVWUDUSRUYHQGHGRURYDORUWRWDOGDVYHQGDVLVWRpDQ~PHURGHSHoDVRYDORUGHFDGDSHoD

Questão 2

2EVHUYHRFyGLJRDEDL[RHFODVVL¿TXHRDOJRULWPRXWLOL]DGRFRPUHODomRDHVWUXWXUDGHSURJUDPDomR SURG

IRU[ Q[![

prod *= x; return(prod);

a) Recursivo.

b) Iterativo.

c) Retroativo.

AGORA

_É

A

_SUA

VEZ

d) Analítico incremental.

e) 1HQKXPDGDVDOWHUQDWLYDVpYHUGDGHLUD

Questão 3

4XDODVDtGDHVSHUDGDDSyVDH[HFXomRGRSURJUDPDUHFXUVLYRDEDL[R long potencia(int n, int p) {

LIS ^ UHWXUQ } else { LIS

Q SRWHQFLDQS

return n; } }

int main(){

SULQWI³3RWrQFLD G?Q´SRWHQFLD V\VWHP³3$86(´

UHWXUQ }

a) 6.

b) 5.

c) 8.

d) 9.

Questão 4

%DVHDGRQDHVWUXWXUDGHSURJUDPDomRGDOLQJXDJHP&FULHXPSURJUDPDUHFXUVLYRSDUDFDOFXODUDVRPDGRVQSULPHLURVLQWHLURV positivos, sendo n um valor fornecido pelo usuário. Como saída deverá ser mostrado o valor da soma.

4XHVWmR

%DVHDGRQDHVWUXWXUDGHSURJUDPDomRGDOLQJXDJHP&FULDUXPSURJUDPDUHFXUVLYRTXHFDOFXOHRQ~PHUR)LERQDFFLGHXPQ~ PHURSRVLWLYRLQWHLURGH¿QLGRQRSURJUDPDSULQFLSDO&RPRVDtGDGHYHUiVHUPRVWUDGRRQ~PHUR)LERQDFFL

Neste tema você aprendeu conceitos e exemplos práticos sobre recursividade baseada nas estruturas de programação recursivas disponíveis na linguagem C.

$ OLQJXDJHP & p XPD GDV PDLV SRGHURVDV OLQJXDJHQV GH SURJUDPDomR HOD WHP UHFXUVRV SDUD LPSOHPHQWDomR GH SUREOHPDVFRPSOH[RVFOiVVLFRVGDFLrQFLDGD&RPSXWDomR8PGHVVHVUHFXUVRVpMXVWDPHQWHDUHFXUVLYLGDGHTXH permite a solução de problemas complexos de forma simples.

$OpPGLVVRIRLDERUGDGDDGH¿QLomRGHDOJRULWPRUHFXUVLYRHSRGHVHYHUL¿FDUTXHXPDLPSRUWDQWHH[LJrQFLDSDUDTXH XPDOJRULWPRUHFXUVLYRHVWHMDFRUUHWRpTXHHOHQmRSRGHJHUDUXPDVHTXrQFLDLQ¿QLWDGHFKDPDGDVDVLPHVPRSRLV se gerar tal sequência pode nunca terminar sua execução.

PHURSRVLWLYRLQWHLURGH¿QLGRQRSURJUDPDSULQFLSDO&RPRVDtGDGHYHUiVHUPRVWUDGRRQ~PHUR)LERQDFFL

N ê d i l á i b i id d b d d

FINALIZANDO

&$6$9(//$(GXDUGRRecursividade em C. Disponível em: <KWWSOLQJXDJHPFFRPEUUHFXUVLYLGDGHHPF>$FHVVRHP

PDLR

/,0$/HRQDUGRRecursividade em linguagem C. Disponível em: <KWWSSWVOLGHVKDUHQHWOHRROLPDUHFXUVLYLGDGHHPOLQJXDJHPF>.

$FHVVRHPPDLR

7(1(1%$80$DURQ0/$1*6$0<HGLG\DK$8*(167(,10RVKH-(VWUXWXUDVGHGDGRVXVDQGR&6mR3DXOR0DNURQ %RRNV

REFERÊNCIAS

Estrutura de Dados:QD&RPSXWDomRHVWUXWXUDGHGDGRVpXPDIRUPDHVSHFt¿FDGHRUJDQL]DomRHDUPD]HQDPHQWR

GHGDGRVSDUDTXHVHMDPXWLOL]DGRVGHIRUPDH¿FD]$VHVWUXWXUDVGHGDGRVHVHXVDOJRULWPRVVmRPXLWRXWLOL]DGRVQD &LrQFLDGD&RPSXWDomRHPGLYHUVDViUHDVGRFRQKHFLPHQWRHFRPDVPDLVGLIHUHQWHV¿QDOLGDGHVQDVROXomRGHSUR blemas computacionais.

Recursivo:DUHFXUVmRpRSURFHVVRSHORTXDOXPGRVSDVVRVGRSURFHGLPHQWRHPTXHVWmRHQYROYHDUHSHWLomRFRPSOH

ta deste mesmo procedimento tantas vezes quanta forem necessárias para solução de um problema.

Iterativo:SURFHVVRTXHpH[HFXWDGRGLYHUVDVYH]HVSDUDVHFKHJDUDXPUHVXOWDGRHDFDGDYH]JHUDXPUHVXOWDGRSDU

FLDOTXHVHUiXVDGRQDSUy[LPDH[HFXomR5HSHWLGRPXLWDVYH]HV

%RRNV

E t t d D d & W m W W G G G p I t¿ G L m W

GABARITO

Questão 1

Resposta:

#include <iostream> #include <stdio.h> int main() {

LQWTWG>@WRWBJHUDO

ÀRDWSUHFR>@WRWBYHQG

int i;

WRWBJHUDO

IRUL LL

{

SULQWI³?Q'LJLWHDGTXDQWLGDGH³L

VFDQI³G´ TWG>L@

SULQWI³?Q'LJLWHRGƒSUHFR³L

VFDQI³I´ SUHFR>L@

WRWBYHQG TWG>L@SUHFR>L@

SULQWI³?Q7RWDOYHQGLGRSHORYHQGHGRUI?Q´WRWBYHQG

WRWBJHUDO WRWBJHUDOTWG>L@

GABARITO

}

printf(“\n\nTotal geral de peças vendidas %d”, tot_geral); V\VWHP³3$86(´

UHWXUQ }

Questão 2

Resposta: $OWHUQDWLYD%

-XVWL¿FDWLYD(VVHDOJRULWPRpFKDPDGRiterativoSRUTXHHOHUHTXHUDUHSHWLomRH[SOtFLWDGHXPSURFHVVRDWpTXH

determinada condição seja satisfeita. Isso pode ser observado na linha de comando for (x = n; x > 0; x--) que executa o laço de repetição n vezes, sendo n um número inteiro positivo qualquer.

Questão 3

Resposta: Alternativa C.

-XVWL¿FDWLYD 2 UHVXOWDGR GH HOHYDGR DR FXER SRLV R SURJUDPD H[HFXWD UHFXUVLYDPHQWH R Q~PHUR HOHYDGR DR expoente 3.

Questão 4

Resposta:

{

LIQ

Q VRPDUQ

return n; } } int main(){

printf(“Soma= %d \n”, somar(5)); V\VWHP³3$86(´

UHWXUQ }

4XHVWmR

Resposta:

#include <iostream> #include <stdio.h> ORQJ¿ERQDFFLLQWQ^ LIQ ^ UHWXUQ `HOVHLIQ ^ UHWXUQ }else{

UHWXUQ¿ERQDFFLQ¿ERQDFFLQ }

} int main(){

SULQWI³)LERQDFFL G?Q´¿ERQDFFL

V\VWHP³3$86(´ UHWXUQ }