POR DENTRO DO TEMA

(1)

(VWUXWXUDGH'DGRV

Autoria: Carlos Eduardo Cayres | 4

o

_semestre

Tema 03

Pilha

7HPD

Pilha

Autoria: Carlos Eduardo Cayres

Como citar esse documento: CAYRES, Carlos Eduardo. Estrutura de Dados: Pilha. 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. 30

Pág. 31 Pág. 31

Pág. 30 Pág. 27 Pág. 26

ACOMPANHE

NA

WEB

Pág. 3

CONVITE

À

LEITURA

(2)

Pilha

A pilha é uma estrutura de dados capaz de representar conjuntos de dados organizados em ordem linear. Quando

se utilizam vetores nas representações dessas estruturas, são usados endereços contíguos de memória do computador, e a ordem linear é indicada pelos índices dos vetores, sendo que sua implementação em algumas situações pode exigir maior esforço computacional. Tais representações denominam-se pilhas estáticas. Entretanto, quando as estruturas de dados do tipo pilha são representadas por estruturas que contêm o dado e também um ponteiro para o próximo elemento, têm-se elementos encadeados, denominados pilhas dinâmicas.

Este tema apresenta a estrutura de dados do tipo pilha, uma das estruturas de programação muito utilizadas em programação.

$SLOKDpFODVVL¿FDGDFRPR/,)2Last In, First Out), ou seja, como em uma pilha de pratos, por exemplo, o primeiro a ser inserido será o último a ser removido. A estrutura de dados do tipo pilha pode armazenar somente um ou vários dados dependendo se ela for homogênea ou heterogênea. Com relação à pilha, veremos as operações de inserção, consulta, remoção e esvaziamento da pilha.

Apresentaremos os conceitos de pilha, introduziremos seu uso em C com vários exemplos práticos. Abordaremos a GH¿QLomRGHSLOKDHVWiWLFDGLQkPLFDKRPRJrQHDHKHWHURJrQHDEHPFRPRDSUHVHQWDUHPRVH[HPSORVHP&SDUDFDGD GH¿QLomR

3DUD¿QDOL]DUVHUiDSUHVHQWDGRXPSURJUDPDHP&FRPSLOKDGLQkPLFDKHWHURJrQHDTXHLPSOHPHQWDXPVLVWHPDGH controle de estoque. Tal exemplo tem o intuito de demonstrar a versatilidade da linguagem C e da estrutura de dados do tipo pilha.

Pilh

tipo pilha.

POR

DENTRO

DO

TEMA

Quando um elemento de uma pilha contém apenas um tipo de dado, como um número, denomina-se pilha homogênea.

Quando um elemento de uma pilha contém um dado composto, como o nome e o salário de um funcionário,

denomina-se pilha heterogênea.

Uma característica importante da estrutura de dados pilha é que o último elemento inserido será o primeiro a ser UHPRYLGRVHQGRFRQVLGHUDGDGRWLSR/,)2Last In, First Out).

1DSLOKDFDGDHOHPHQWRSRGHDUPD]HQDUXPRXYiULRVGDGRVHVWUXWXUDKRPRJrQHDRXKHWHURJrQHDUHVSHFWLYDPHQWH e um ponteiro para o próximo elemento, permitindo o encadeamento e sempre mantendo a estrutura linear.

As operações de inserir na pilha, consultar toda a pilha, remover e esvaziar toda a pilha são as manipulações básicas da estrutura utilizadas na maioria dos problemas.

4XDOTXHUHVWUXWXUDGHVVHWLSRSRVVXLXPSRQWHLURGHQRPLQDGR7232QRTXDOWRGDVDVRSHUDo}HVGHLQVHUomRHUHPRomR acontecem. Assim, as operações ocorrem sempre na mesma extremidade da estrutura.

Inserção e Remoção na Pilha

A operação de inserção e remoção na pilha sempre realiza operações básicas, como a de atribuição, para atualizar RWRSRGDSLOKD/RJRVmRRSHUDo}HVGHWHPSRFRQVWDQWHHJDVWDPWHPSR2

Já a operação de consultar toda a pilha percorre todos os elementos armazenados nela. Considerando que uma pilha FRQWpPQHOHPHQWRVRWHPSRGHH[HFXomRVHUi2Q

$RSHUDomRGHHVYD]LDPHQWRGDSLOKDFRQVLVWHHPUHPRYHUWRGRVRVHOHPHQWRVGHOD2WHPSRJDVWRQHVVDRSHUDomR depende da linguagem de programação que está sendo utilizada. Na linguagem C, é necessário desalocar cada um dos HOHPHQWRVGDSLOKDJDVWDQGRWHPSRSURSRUFLRQDODRWDPDQKRGHODRXVHMD2Q

Exemplos

Pilha Estática e Homogênea

6mRHVWUXWXUDVTXHWrPVHXWDPDQKRSUHGH¿QLGRRTXDOQmRSRGHVHUDOWHUDGRGXUDQWHDH[HFXomRGRSURJUDPD

e só manipulam um tipo de dado. Como exemplo, a variável do tipo inteiro numero.

(3)

#include<iostream> #include<stdio.h> LQWPDLQ {

int numero[5], op, topo=0, i; do

{

V\VWHP³&/6´ SULQWI³?Q?W0(18´

SULQWI³?Q,QVHULUQ~PHURHPSLOKDU´

SULQWI³?Q&RQVXOWDUWRSR´

SULQWI³?Q&RQVXOWDUWRGDDSLOKD´

SULQWI³?Q([FOXLUGHVHPSLOKDU´

SULQWI³?Q(VYD]LDUDSLOKD´

SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSomR³

VFDQI³G´ RS

LIRS__RS!

SULQWI³?Q2SomRLQYiOLGD?Q´ LIRS

{

LIWRSR

SULQWI³?Q3LOKDFKHLD?Q´

else

{

SULQWI³?Q'LJLWHRQPHURDVHULQVHULGR³ VFDQI³G´ QXPHUR>WRSR@

topo++;

SULQWI³?Q1PHURLQVHULGR?Q´

}

LIRS

{

LIWRSR

SULQWI³?Q3LOKDYD]LD?Q´

else

SULQWI³?Q7RSRG³QXPHUR>WRSR@

}

LIRS

{

LIWRSR

else

{

SULQWI³?Q1PHURVHPSLOKDGRV´

IRUL WRSRL! L {

SULQWI³G´QXPHUR>L@

}

LIRS

{

LIWRSR

else

{

topo--;

(4)

SULQWI³?Q1~PHURGHVHPSLOKDGR?Q´

}

LIRS

{

LIWRSR

SULQWI³?Q3LOKDYD]LD?Q´ else

{

topo=0;

SULQWI³?Q3LOKDHVYD]LDGD?Q´

}

V\VWHP³3$86(´

`ZKLOHRS

}

Pilha Estática e Heterogênea

6mRHVWUXWXUDVTXHWrPVHXWDPDQKRSUHGH¿QLGRRTXDOQmRSRGHVHUDOWHUDGRGXUDQWHDH[HFXomRGRSURJUDPDH

manipulam mais de um tipo de dado. Como exemplo, as variáveis do tipo inteiro codigo e do tipo real salario.

#include<iostream> #include<stdio.h> LQWPDLQ { struct {

int codigo; ÀRDWVDO } pilha[5];

int op,topo=0,i; do

{

V\VWHP³&/6´ SULQWI³?Q?W0(18´

SULQWI³?Q&DGDVWUDUHPSLOKDU´ SULQWI³?Q&RQVXOWDUWRSR´ SULQWI³?Q&RQVXOWDUWRGDDSLOKD´ SULQWI³?Q([FOXLUGHVHPSLOKDU´ SULQWI³?Q(VYD]LDUDSLOKD´ SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSomR³ VFDQI³G´ RS

LIRS__RS!

{

LIWRSR

SULQWI³?Q3LOKDFKHLD?Q´

else

{

SULQWI³?Q'LJLWHRFyGLJRDVHUHPSLOKDGR³

VFDQI³G´ SLOKD>WRSR@FRGLJR

SULQWI³?Q'LJLWHRVDOiULR³

VFDQI³I´ SLOKD>WRSR@VDO

topo++;

SULQWI³?Q'DGRVHPSLOKDGRV?Q´

}

(5)

LIRS

{

LIWRSR

else

{

SULQWI³?QFyGLJRGRWRSRG´SLOKD>WRSR@FRGLJR

SULQWI³?Q6DOiULRGRWRSRI´SLOKD>WRSR@VDO

}

LIRS

{

LIWRSR

else

{

SULQWI³?Q'DGRVHPSLOKDGRV´

IRUL WRSRL! L

{

SULQWI³?Q&yGLJRG´SLOKD>L@FRGLJR

SULQWI³?Q6DOiULRI´SLOKD>L@VDO

}

LIRS

{

LIWRSR

else

{

topo--;

SULQWI³?Q&yGLJRGHVHPSLOKDGR?Q´

}

LIRS

{

LIWRSR

{

topo=0;

}

V\VWHP³3$86(´

`ZKLOHRS

}

Pilha Dinâmica e Homogênea

São estruturas que utilizam ponteiros para indexar endereços de variáveis, permitindo a inserção dinâmica de dados

durante a execução do programa, e manipulam apenas um tipo de dado. Como exemplo, a variável do tipo inteiro num.

struct pilha {

int num;

(6)

pilha *prox; };

pilha *topo,*aux;

int op;

WRSR 18//

do {

V\VWHP³&/6´

SULQWI³?Q0(18´

SULQWI³?Q,QVHULU´

SULQWI³?Q&RQVXOWDUSLOKD´

SULQWI³?Q([FOXLU´

SULQWI³?Q(VYD]LDUSLOKD´

SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSomR³

VFDQI³G´ RS

LIRS__RS!

SULQWI³?Q2SomRLQYiOLGD?Q´

LIRS

{

DX[ QHZSLOKD

SULQWI³?Q'LJLWHRQ~PHUR³

VFDQI³G´ DX[!QXP

aux->prox=topo; topo=aux;

SULQWI³?Q1~PHURLQVHULGR?Q´

}

LIRS

{

LIWRSR 18//

else {

SULQWI³?Q1~PHURGRWRSR³

SULQWI³G´WRSR!QXP

} }

LIRS

{

LIWRSR 18//

else {

aux=topo;

SULQWI³?Q7RGDDSLOKD³

ZKLOHDX[ 18//

{

SULQWI³G´DX[!QXP

aux=aux->prox; }

} }

LIRS

{

LIWRSR 18//

else

(7)

{

aux=topo;

topo=topo->prox;

GHOHWHDX[

SULQWI³?Q1~PHURGRWRSRH[FOXLGR?Q´

} }

LIRS

{

LIWRSR 18//

else {

ZKLOHWRSR 18//

{

aux=topo; topo=topo->prox;

GHOHWHDX[

}

} }

V\VWHP³3$86(´

}

ZKLOHRS

}

Pilha Dinâmica e Heterogênea

São estruturas que utilizam ponteiros para indexar endereços de variáveis, permitindo a inserção dinâmica de dados durante a execução do programa, e manipulam mais de um tipo de dado. Como exemplo, as variáveis do tipo

inteiro codigo e do tipo real salario.

struct pilha {

int codigo;

ÀRDWVDODULR

pilha *prox; };

pilha *topo,*aux; int op; WRSR 18// do {

V\VWHP³&/6´

SULQWI³?Q0(18´

SULQWI³?Q,QVHULU´

SULQWI³?Q&RQVXOWDUSLOKD´

SULQWI³?Q([FOXLU´

SULQWI³?Q(VYD]LDUSLOKD´

SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSÁDR³

VFDQI³G´ RS

(8)

LIRS__RS!

SULQWI³?Q2SÁDRLQYOLGD´

LIRS

{

DX[ QHZSLOKD

SULQWI³?Q'LJLWHRFyGLJRDLQVHULU³

VFDQI³G´ DX[!FRGLJR

SULQWI³?Q'LJLWHRVDOiULR³

VFDQI³I´ DX[!VDODULR

SULQWI³?'DGRVLQVHULGRV?Q´

}

LIRS

{

LIWRSR 18//

{

SULQWI³?Q,QIRUPDo}HVGRWRSR?Q´

SULQWI³?&yGLJRG´WRSR!FRGLJR

SULQWI³?Q6DODULRI´WRSR!VDODULR

} }

LIRS

{

LIWRSR 18//

{

aux=topo;

SULQWI³?Q7RGDDSLOKD?Q´

ZKLOHDX[ 18//

{

SULQWI³?Q&yGLJRG´DX[!FRGLJR

SULQWI³?Q6DODULRI?Q´DX[!VDODULR

aux=aux->prox; }

} }

LIRS

{

LIWRSR 18//

else {

aux=topo;

topo=topo->prox;

GHOHWHDX[

SULQWI³?Q,QIRUPDo}HVGRWRSRH[FOXtGDV?Q´

} }

LIRS

{

LIWRSR 18//

else {

(9)

ZKLOHWRSR 18//

{

aux=topo;

topo=topo->prox;

GHOHWHDX[

}

} }

V\VWHP³3$86(´

`ZKLOHRS

}

Exemplo de Controle de Estoque Utilizando Pilha Dinâmica Heterogênea #include <iostream>

#include <stdio.h> #include <dos.h> LQWPDLQ {

struct pilha {

int cod_op, cod_prod, qtde, dia, mes, ano; pilha *posi;

};

pilha *novo, *topo, *aux; //capturando a data do sistema VWGWLPHBWWW VWGWLPH VWGWPWWP VWGORFDOWLPH WW int mday = ttm.tm_mday; LQWPPRQ WWPWPBPRQ

LQWP\HDU WWPWPB\HDU

int op, dia, mes, ano, prod, cod, qtd, estoque; WRSR 18//

do {

V\VWHP³&/6´ SULQWI³?Q0HQX³

SULQWI³?Q&DGDVWUDURSHUDomR´

SULQWI³?Q&RQVXOWDURHVWRTXHGHXPSURGXWR´ SULQWI³?Q&RQVXOWDUDVRSHUDo}HVDSDUWLUGHXPDGDWD´ SULQWI³?Q&RQVXOWDUWRWDOGHSURGXWRVHPHVWRTXH´ SULQWI³?Q&RQVXOWDUWRWDOGHSHUGDV´

SULQWI³?Q5HWLUDUD~OWLPDRSHUDomRFDGDVWUDGD´ SULQWI³?Q(VYD]LDUHVWRTXH´

SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSomR³ VFDQI³G´ RS

LIRS__RS!

{

SULQWI³?Q&RPSUD´ SULQWI³?Q9HQGD´ SULQWI³?Q3HUGD´ SULQWI³?Q'HYROXomR´

SULQWI³?Q'LJLWHRWLSRGHRSHUDomR³ VFDQI³G´ FRG

ZKLOHFRG__FRG!

(10)

{

SULQWI³?Q2SHUDomRLQYiOLGD?Q´

SULQWI³?Q?Q'LJLWHQRYDPHQWH³

VFDQI³G´ FRG

}

SULQWI³?Q'LJLWHRFGLJRGRSURGXWR³ VFDQI³G´ SURG

SULQWI³?Q'LJLWHDTXDQWLGDGHGRSURGXWR³ VFDQI³G´ TWG

ZKLOHTWG

{

SULQWI³?Q4XDQWLGDGHLQYiOLGD?Q´

SULQWI³?Q'LJLWHQRYDTXDQWLGDGH³

VFDQI³G´ TWG

}

LIWRSR 18//SLOKDYD]LDSULPHLUDLQFOXVmR {

LIFRG __FRG

SULQWI³?Q(VWRTXHYD]LRLPSRVVtYHOFDGDVWUDUHVVDRSHUDomR?Q´

else

{

QRYR QHZSLOKD

novo->dia=mday;

novo->mes=mmon;

novo->ano=myear;

novo->cod_op=cod;

novo->cod_prod=prod;

novo->qtde=qtd;

novo->posi=topo;

topo=novo;

SULQWI³?Q2SHUDomRFDGDVWUDGD?Q´

}

HOVHMiH[LVWHDOJXPSURGXWRFDGDVWUDGRYHUL¿FDUHVWRTXH {

LIFRG __FRG

{

estoque=0;

aux=topo;

ZKLOHDX[ 18//

{

LIDX[!FRGBSURG SURG

{

LIDX[!FRGBRS __DX[!FRGBRS

estoque=estoque+aux->qtde;

else

estoque=estoque-aux->qtde;

}

aux=aux->posi;

}

LITWG!HVWRTXH

SULQWI³?Q(VWRTXHLQVX¿FLHQWH?Q´

else

{

QRYR QHZSLOKD

novo->dia=mday;

novo->mes=mmon;

novo->ano=myear;

(11)

novo->cod_op=cod;

novo->qtde=qtd;

novo->posi=topo;

topo=novo;

}

else

{

QRYR QHZSLOKD

novo->dia=mday;

novo->mes=mmon;

novo->ano=myear;

novo->cod_op=cod;

novo->qtde=qtd;

novo->posi=topo;

topo=novo;

}

} }

LIRS FRQVXOWDURHVWRTXHGHXPGHWHUPLQDGRSURGXWR {

LIWRSR 18// SULQWI³?Q(VWRTXHYD]LR?Q´ else

{

estoque=0;

SULQWI³?Q'LJLWHRFyGLJRGRSURGXWRTXHGHVHMDFRQVXOWDURHVWRTXH³ VWGFLQ!!FRG

aux=topo; ZKLOHDX[ 18// {

LIDX[!FRGBSURG FRG

{

else

}

aux=aux->posi; }

SULQWI³?Q4XDQWLGDGHHPHVWRTXHG´HVWRTXH

} }

LIRS {

LIWRSR 18//

SULQWI³?Q(VWRTXHYD]LR?Q´ else

{

SULQWI³?Q'LJLWHRGLD³ VFDQI³G´ GLD SULQWI³?Q'LJLWHRPrV³ VFDQI³G´ PHV

(12)

SULQWI³?Q'LJLWHRDQRFRPGtJLWRV³ VFDQI³G´ DQR

estoque=0; aux=topo; ZKLOHDX[ 18// {

LIDX[!GLD! GLD DX[!PHV! PHV DX[!DQR! DQR

{

LIDX[!FRGBRS

SULQWI³?Q&RPSUDHPGGG´DX[!GLDDX[!PHVDX[!DQR

LIDX[!FRGBRS

SULQWI³?Q9HQGDHPGGG´DX[!GLDDX[!PHVDX[!DQR

LIDX[!FRGBRS

SULQWI³?Q3HUGDHPGGG´DX[!GLDDX[!PHVDX[!DQR

LIDX[!FRGBRS

SULQWI³?Q'HYROXomRHPGGG´DX[!GLDDX[!PHVDX[!DQR

SULQWI³3URGXWRGHFyGLJR GG´DX[!FRGBSURGDX[!TWGH

}

aux=aux->posi; }

} }

LIRS {

LIWRSR 18//

{

estoque = 0;

aux=topo; ZKLOHDX[ 18// {

else

aux=aux->posi; }

SULQWI³?Q4XDQWLGDGHHPHVWRTXHG´HVWRTXH }

}

LIRS FRQVXOWDUWRWDOGHSHUGDV {

{

estoque = 0; aux=topo; ZKLOHDX[ 18// {

LIDX[!FRGBRS

aux=aux->posi; }

SULQWI³?Q7RWDOGHSHUGDV G´HVWRTXH }

}

LIRS

(13)

{

aux = topo; topo = topo->posi; GHOHWHDX[

SULQWI³?QÒOWLPDRSHUDomRH[FOXtGD?Q´ }

} LIRS {

LIWRSR 18//

{

aux = topo; ZKLOHDX[ 18// {

topo = aux->posi; GHOHWHDX[ aux = topo; }

SULQWI³?Q3LOKDHVYD]LDGD?Q´ }

}

V\VWHP³3$86(´ }

ZKLOHRS }

FEOFILOFF, Paulo.

Pilhas

.

• A estrutura de dados pilha é uma das estruturas de dados que suportam a inserção e remoção de elementos. Ela respeita a regra que o primeiro elemento inserido na pilha é o último a ser UHPRYLGR7DOUHJUDpFRQKHFLGDSHODVLJOD/,)2Last-In, First-Out).

'LVSRQtYHOHP<KWWSZZZLPHXVSEUaSIDOJRULWPRVDXODVSLOKDKWPO>$FHVVRHPPDLR

ROCHA, Fabio Gomes.

Pilha

: Fundamentos e implementação da estrutura em

Java.

• Uma questão importante no estudo da computação é o entendimento das estruturas de dados, HQWUHDVTXDLVWHPRV¿ODVSLOKDVOLVWDVOLJDGDVHQWUHRXWUDV(QWHQGDDTXLRIXQFLRQDPHQWRGDV pilhas e como implementar uma pilha simples.

'LVSRQtYHOHP<KWWSZZZGHYPHGLDFRPEUSLOKDVIXQGDPHQWRVHLPSOHPHQWDFDRGDHVWUXWXUDHPMD

-YD>$FHVVRHPDJR

Estrutura de Dados I - Aula3 Parte1 Pilha.

• 9RFrFRPSUHHQGHUiRFRQFHLWRGDHVWUXWXUDGHGDGRVSLOKDHYDLH[SORUDUDVGLIHUHQoDVHQWUH

as variações de implementação da pilha.

'LVSRQtYHOHP<KWWSVZZZ\RXWXEHFRPZDWFK"Y \E;G<97N>$FHVVRHPDJR 7HPSR

O

(14)

Pilhas - Vídeo Aula [Java].

• 1HVWHYtGHRYRFrFRPSUHHQGHUiRFRQFHLWRGHSLOKDFRPRXPDHVWUXWXUDGHGDGRVLGHQWL¿FDUi

as diferenças entre a implementação de pilha, utilizando alocação de memória encadeada.

'LVSRQtYHOHP<KWWSVZZZ\RXWXEHFRPZDWFK"Y K)9G),V'R>$FHVVRHPDJR 7HPSR

Instruções:

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

HVFROKDHGLVVHUWDWLYDV/HLDFXLGDGRVDPHQWHRVHQXQFLDGRVHDWHQWHVHSDUDRTXHHVWiVHQGRSHGLGR

S

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 haverá muitos exemplos e exercícios baseados na linguagem C.

Problema proposto:,PSOHPHQWDUXPSURJUDPDHP&TXHFDUUHJXHXPYHWRUFRPQ~PHURVLQWHLURVSRVLWLYRV2SURJUDPD GHYHUiH[HFXWDUDVRSHUDo}HVDVHJXLU

,QVHULUQ~PHUR /LVWDUWRGRVRVQ~PHURV &RQVXOWDUXPQ~PHUR ([FOXLUXPQ~PHUR

Observação: 2YHWRUQmRSUHFLVDVHURUGHQDGRHGHYHUiSHUPLWLUDLQVHUomRGHQ~PHURVUHSHWLGRV

AGORA

_É

A

_SUA

VEZ

Questão 2

2EVHUYHRFyGLJRDVHJXLUHFODVVL¿TXHRWLSRGHSLOKDXWLOL]DGDFRPUHODomRjHVWUXWXUDGHSURJUDPDomR DX[ QHZSLOKD

VFDQI³G´ DX[!QXP

aux->prox=topo;

topo=aux;

a) 'LQkPLFD

b) Estática.

c) ,QFUHPHQWDO

d) Analítica.

e) Nenhuma das alternativas anteriores.

Questão 3

$HVWUXWXUDGHGDGRVGRWLSRSLOKDFRPUHODomRjVRSHUDo}HVGHLQVHUomRHUHPRomRSRGHVHUFODVVL¿FDGDFRPR

a) ),)2

b) /,)2

c) /2)2

d) )2),

(15)

Questão 4

Com base na estrutura de programação da linguagem C, criar um programa que carregue uma pilha dinâmica para manipular uma HVWUXWXUDFRQWHQGRDQRWDDQRWDHDPpGLDGHDOXQRV5HVROYHURVLWHQVDVHJXLU

a) /HUDVQRWDVGRVDOXQRV

b) Calcular as médias aritméticas das notas.

c) /LVWDUDVPpGLDVGHWRGRVRVDOXQRV

d) $R¿QDOL]DURSURJUDPDHVYD]LDUDSLOKD

Questão 5

Com base na estrutura de programação da linguagem C, criar um programa que carregue uma pilha dinâmica heterogênea para UHVROYHURVLWHQVDVHJXLU

Cadastrar funcionário.

Consultar todos os funcionários.

Consultar a média salarial.

Conceder aumento porcentual.

5) Excluir um funcionário.

Sair.

Observação:$HVWUXWXUDGHVWDSLOKDDUPD]HQDUiRVVHJXLQWHVGDGRV

• Nome do funcionário.

• Salário.

2VFRQFHLWRVHH[HPSORVSUiWLFRVHP&DSUHVHQWDGRVQHVWHWHPDGHL[DUDPEHPFODURTXHDHVWUXWXUDGHGDGRV do tipo pilha é muito versátil na solução de problemas do cotidiano. Sua estrutura permite armazenar tipos de dados variados, possibilitando o trabalho com estruturas homogêneas e heterogêneas.

As operações básicas de inserção, consulta, remoção e esvaziamento da pilha foram bem-exploradas nos exemplos e exercícios propostos, bem como as estruturas de pilha estática, dinâmica, homogênea e heterogênea com exemplos em C para cada uma das estruturas.

2 L O i L & G G L E O G G G

FINALIZANDO

)(2),/2))3DXOR. Pilhas. 'LVSRQtYHOHP<KWWSZZZLPHXVSEUaSIDOJRULWPRVDXODVSLOKDKWPO>$FHVVRHPPDLR 52&+$)DELR*RPHVPilhas:)XQGDPHQWRVHLPSOHPHQWDomRGDHVWUXWXUDHP-DYD'LVSRQtYHOHP<KWWSZZZGHYPHGLD

FRPEUSLOKDVIXQGDPHQWRVHLPSOHPHQWDFDRGDHVWUXWXUDHPMDYD>$FHVVRHPPDLR

5266,1,$OH[DQGUHHWDOEstrutura de Dados I$XOD3DUWH3LOKD'LVSRQtYHOHP<KWWSVZZZ\RXWXEHFRPZDWFK"Y \E;G<97N>. $FHVVRHP

7(1(1%$80$DURQ0/$1*6$0<HGLG\DK$8*(167(,10RVKH-Estruturas de dados usando C6mR3DXOR0DNURQ

%RRNV

C para cada uma das estruturas.

(16)

Estrutura de Dados:QD&RPSXWDomRHVWUXWXUDGHGDGRVpXPDIRUPDHVSHFt¿FDGHRUJDQL]DomRHDUPD]HQDPHQWR GHGDGRVSDUDTXHVHMDPXWLOL]DGRVGHIRUPDH¿FD]$VHVWUXWXUDVGHGDGRVHVHXVDOJRULWPRVVmRPXLWRXWLOL]DGRVQD

&LrQFLDGD&RPSXWDomRHPGLYHUVDViUHDVGRFRQKHFLPHQWRHFRPDVPDLVGLIHUHQWHV¿QDOLGDGHVQDVROXomRGHSUR

-blemas computacionais.

Heterogênea: aquilo que é composto por elementos diferentes, desiguais.

Homogênea:FXMDVSDUWHVVmRGDPHVPDQDWXUH]DRXHVWmRHVWUHLWDPHQWHOLJDGDV,GrQWLFDLJXDODQiORJD

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

o ogê ea FXMDV SD WHV VmR GD HV D DWX H D RX HVWmR HVW H WD H WH JDGDV Gr W FD JXD D i RJD

GABARITO

Questão 1

Resposta:

LQWYHW>@RSLMDFKRXQXP i=0;

do {

V\VWHP³&/6´ SULQWI³?Q0(18´

SULQWI³?Q,QVHULUQ~PHUR´

GABARITO

SULQWI³?Q&RQVXOWDUWRGRVRVQ~PHURV´ SULQWI³?Q&RQVXOWDUXPQ~PHUR´ SULQWI³?Q([FOXLUXPQ~PHUR´ SULQWI³?Q6DLU´

SULQWI³?Q?Q'LJLWHVXDRSomR³ VFDQI³G´ RS

LIRS__RS!

SULQWI³2SomRLQYiOLGD?Q´ LIRS

{

LIL

SULQWI³?Q9HWRUORWDGR´ else

{

SULQWI³?Q'LJLWHRQ~PHURDVHULQVHULGR³

VFDQI³G´ YHW>L@

SULQWI³?Q1~PHURLQVHULGR?Q´

i++;

}

} LIRS { LIL

SULQWI³?Q9HWRUYD]LR?Q´

else

{

SULQWI³?Q1XPHURVFDGDVWUDGRV³

IRUM MLM

SULQWI³G³YHW>M@

(17)

SULQWI³?Q´

} LIRS {

LIL

else

{

SULQWI³?Q'LJLWHRQ~PHURDVHUFRQVXOWDGR³

VFDQI³G´ QXP

achou=0;

IRUM MLM

{

LIQXP YHW>M@

achou++;

}

LIDFKRX

SULQWI³?Q1~PDURQDRHQFRQWUDGR?Q´

HOVHLIDFKRX

SULQWI³1~PHURHQFRQWUDGRYH]?Q´

HOVHSULQWI³1~PHURHQFRQWUDGRGYH]HV?Q´DFKRX

}

} LIRS { LIL

else

{

SULQWI³?Q'LJLWHRQ~PHURDVHUH[FOXtGR³

VFDQI³G´ QXP

achou=0;

j=0;

ZKLOHML

{

LIQXP YHW>M@

{

LQWN

achou++;

IRUN MNLN

{

YHW>N@ YHW>N@

}

i--;

}

else j++;

}

LIDFKRX

SULQWI³?Q1~PDHRQDRHQFRQWUDGR?Q´

HOVHLIDFKRX

SULQWI³?Q1~PHURH[FOXtGRYH]?Q´

HOVHSULQWI³?Q1~PHURH[FOXtGRGYH]HV?Q´DFKRX

}

V\VWHP³3$86(´ `ZKLOHRS }

Clique aqui para voltar à seção Agora é a Sua Vez.

(18)

Questão 2

Resposta: Alternativa A.

A linhas de comando aux=new(pilha); e aux->prox=topo; mostram claramente uma estrutura de alocação dinâmica no

trecho de código da questão.

Questão 3

Resposta: Alternativa B.

A estrutura de dados do tipo pilha tem como uma de suas principais características o fato de que o último elemento a ser

inserido é o primeiro a ser removido, ou seja, em inglês Last-In, First-Out/,)2

Questão 4

Resposta:

struct pilha

{

ÀRDWQRWD

ÀRDWPHGLD

pilha * prox; };

pilha *topo, *aux; int j, i, cont;

WRSR 18//

V\VWHP³&/6´

IRUL L L

{

DX[ QHZSLOKD

SULQWI³'LJLWHDQRWDGRGDOXQR³L

VFDQI³I´ DX[!QRWD

SULQWI³'LJLWHDQRWDGRGDOXQR³L

VFDQI³I´ DX[!QRWD

} aux = topo;

ZKLOHDX[ 18//

{

DX[!PHGLD DX[!QRWDDX[!QRWD

aux = aux->prox;

} aux = topo;

FRQW

ZKLOHDX[ 18//

{

SULQWI³?Q0HGLDGRGDOXQR I?Q´FRQWDX[!PHGLD

aux = aux->prox; }

aux = topo;

ZKLOHDX[ 18//

{

topo = topo->prox;

GHOHWHDX[

aux = topo; }

(19)

V\VWHP³3$86(´

}

Clique aqui para voltar à seção Agora é a Sua Vez.

Questão 5

Resposta:

#include <iostream> #include <stdio.h> LQWPDLQ {

struct pilha {

int codigo;

ÀRDWVDO

pilha *prox; };

pilha *aux, *topo;

WRSR 18//

int op,qtde;

ÀRDWVRPDPHGLDSHUF

do {

V\VWHP³&/6´ SULQWI³?Q0(18´

SULQWI³?Q&DGDVWUDUIXQFLRQDULR´ SULQWI³?Q&RQVXOWDUWRGRVRVIXQFLRQDULRV´ SULQWI³?Q&RQVXOWDUDPHGLDVDODULDO´

SULQWI³?Q&RQFHGHUDXPHQWRSHUFHQWXDO´ SULQWI³?Q([FOXLUXPIXQFLRQDULR´ SULQWI³?Q6DLU´

SULQWI³?Q'LJLWHVXDRSFDR³ VFDQI³G´ RS

LIRS__RS! VWGFLQ!!RS LIRS

{

DX[ QHZSLOKD

SULQWI³?Q'LJLWHRFRGLJRGRIXQFLRQDULR³

VFDQI³G´ DX[!FRGLJR

SULQWI³?Q'LJLWHRVDODULRGRIXQFLRQDULR³

VFDQI³I´ DX[!VDO

aux->prox=topo;

topo=aux;

SULQWI³?Q)XQFLRQDULRFDGDVWUDGR?Q´

}

LIRS

{

LIWRSR 18//

SULQWI³?Q1HQKXPIXQFLRQDULRFDGDVWUDGR?Q´

else

{

SULQWI³?Q/LVWDJHPGRVIXQFLRQDULRV³

aux=topo;

ZKLOHDX[ 18//

{

SULQWI³?QG?QI?Q´DX[!FRGLJRDX[!VDO

(20)

aux=aux->prox;

}

LIRS

{

LIWRSR 18//

else

{

soma=0;

qtde=0;

aux=topo;

ZKLOHDX[ 18//

{

soma=soma+aux->sal;

TWGH TWGH

aux=aux->prox;

}

media=soma/qtde;

SULQWI³?Q0HGLDVDODULDO I?Q´PHGLD

}

LIRS

{

LIWRSR 18//

else

{

SULQWI³?Q'LJLWHRDXPHQWRSHUFHQWXDOGHVHMDGR³ VFDQI³I´ SHUF

aux=topo;

ZKLOHDX[ 18//

{

DX[!VDO DX[!VDODX[!VDOSHUF

aux=aux->prox;

}

SULQWI³?Q$XPHQWRHIHWXDGR?Q´

}

LIRS

{

LIWRSR 18//

else

{

aux=topo;

topo=topo->prox;

GHOHWHDX[

SULQWI³?Q)XQFLRQDULRH[FOXLGR?Q´

}

V\VWHP³3$86(´

`ZKLOHRS

LIWRSR 18//

{

(21)

aux=topo;

ZKLOHDX[ 18//

{

topo=topo->prox;

GHOHWHDX[

aux=topo;

}

SULQWI³?Q7RGRVRVIXQFLRQDULRVIRUDPH[FOXLGRV?Q´ V\VWHP³3$86(´

} }