estruturas de dados elementares - INPE
Propaganda
CAP-241–ComputaçãoAplicadaI
Aula5–EstruturasdeDadosElementares
ParteI–Arranjos,Listas,PilhaseFilas
Dr.GilbertoRibeirodeQueiroz
SãoJosédosCampos,14deAbrilde2016
VisãoGeraldaAula
• EstruturasdedadosElementares:
–
–
–
–
–
Listas.
Pilhas.
Filas.
Árvores.
FilasdePrioridade
• ContainersdaBibliotecaSTL
• ConsideraçõesFinais.
• LeiturasComplementares.
• Exercícios.
EstruturasdeDados
• AssimcomonamatemáWca,conjuntospossuemumpapel
importantenaCiênciadaComputação:
– Adiferençabásica,équeosconjuntomanipuladosporalgoritmos
podemcresceroudiminuircomotempo,ouatémesmomodificaros
valoresdeitens.
– Conjuntosemcomputaçãopossuemumanaturezadinâmica.
• Oprojetodealgoritmos,quasesempre,dependedealgumWpode
representaçãoparaoconjuntodedados,sejaeledeentradaou
saída,ouatémesmoumconjuntomanWdodeformatemporária
duranteoprocessamentodoalgoritmo.
• Alémdisso,cadaalgoritmopossuiseusrequisitosnahorade
manipularconjuntos.
EstruturasdeDados
• Exemplo:Umfamosoalgoritmoparacomputaçãodos
pontosdeintersecçãoentreconjuntosdesegmentos
dereta,precisadeumconjuntoauxiliarpara:
ü Inserireventos,querepresentampontosextremosdos
segmentosoupontosdeintersecçãojádetectados;
ü Obteroeventocommenorvalordeabscissa(ou
ordenada);
ü Removereventosjáprocessados;
ü Verificarseumdadoeventojáseencontranoconjunto.
EstruturasdeDados
• Umadastécnicasfundamentaisparaconstruçãodebons
algoritmosconsisteemorganizaroconjuntodedadosmanipulados
deformaqueasoperaçõessobreessesdadossejamrealizadasde
formaeficiente.
• AsestruturasdedadossãoabstraçõesuWlizadasparaorganizaros
dadosdeformaapropiciarumusoeficienteporpartedos
algoritmos.
• Estruturasdedadosmaiselementaresparaorganizaçãodosdados
queiremosvernocurso:
– arranjos,listas,pilhas,filaseárvores.
– EstasestruturasrepresentamosexemplosclássicosdeWposabstratos
dedados(TAD).
TerminologiaBásica
• Oselementosdeumconjuntoserãorepresentadosporobjetos,que
podemconterdiversosatributos.
• Emalgumassituações,assumiremosqueumdessesatributospossuium
papelespecial:
– iden<ficaroobjeto⇒chave(key).
– Achave,emgeral,irápertenceraumconjuntototalmenteordenado:
• númerosreais
• strings(ordemlexicográfica).
• Essanoçãodeordemtotaléimportantepoisnospermitedefiniromenor
emaiorelementosdeumconjunto,opróximoelementomaiorqueum
dadoelementodoconjunto.
• Osobjetospodemcontertambémalgunsatributosespeciais,uWlizados
exclusivamentepelasestruturasdedados.
Arranjos
(arrays)
Um arranjo representa uma quanWdade fixa
deelementosdedadosquesãoarmazenados
de forma conBgua na memória e são
acessíveisatravésdeíndices.
Vetores:sãoarranjosunidimensionais.
Matrizes:sãoarranjosbidimensionais.
ArranjosemLinguagensdeProgramação
• ArranjosEstáWcos:
– SuportadosporWposprimiWvosdalinguagemdeprogramação.
– EsteWpodearranjopossuiumtamanhofixoemtempodecompilação,ouseja,
precisamos“adivinhar”otamanhodoarranjoqueprecisaremosusaremtempode
compilação.
– EmCeC++,temosacondiçãodecriarvetoresematrizesmulWdimensionaiscomessas
caracterísWcas.
0 1 2
intprimos[3]={2,3,5};
doublevalores[2][3]={
{8,5,3},
{1,7,6}
};
primos 235
0 1 2
valores
0 853
1 176
ArranjosemLinguagensdeProgramação
• ArranjosDinâmicos:
– EsteWpodearranjopossuiumtamanhofixo,masquepodeserdefinidoemtempode
execução.
– Suportadoscomousodefunçõesouoperadoresdalinguagemcapazesdealocarblocos
dememóriaemtempodeexecução:
•
•
EmCtemosafamíliadefunções:malloc,calloc,reallocefree.
EmC++,temososoperadoresnew,new[],deleteedelete[].
– Algumaslinguagensoferecemestruturaspararepresentaçãodematrizesdinâmicas,isto
é,umamatrizcujaasdimensõespodemserespecificadasemtempodeexecução.
Jáestudamoscomofuncionaaalocação
dinâmicadememóriaemC.
ArranjosemLinguagensdeProgramação
• ArranjosDinâmicos:
– EsteWpodearranjopossuiumtamanhofixo,masquepodeserdefinidoemtempode
execução.
– Suportadoscomousodefunçõesouoperadoresdalinguagemcapazesdealocarblocos
dememóriaemtempodeexecução:
•
•
EmCtemosafamíliadefunções:malloc,calloc,reallocefree.
EmC++,temososoperadoresnew,new[],deleteedelete[].
– Algumaslinguagensoferecemestruturaspararepresentaçãodematrizesdinâmicas,isto
é,umamatrizcujaasdimensõespodemserespecificadasemtempodeexecução.
Comofuncionaaalocaçãodinâmicade
memóriaemC++?
PropriedadesdosArranjos
• Umvetorpossuiumaorganizaçãosequencialimplícita,isto
é,atravésdaposiçãoquecadaelementoocupa.
• Oi-ésimoelementodeumvetorV,podeseracessado
atravésdaseguintenotação:V[i].
• Agrandeimportânciadaestruturadedadosarranjoéque
elatemumacorrespondênciacomamemóriado
computador:
– ocódigodemáquinageradoporumcompiladoraparWrdeum
programaemlinguagemdealtonívelparaacessoaositensé
eficiente.
– comentarexercícioE-5.1.
Listas
(Lists)
Listas
• Umalistapodeserusadaparaorganizarum
conjuntodeelementossequencialmente.
Itemdedado
elemento
L
I
ligações
S
T
A
FormasdoEncadeamento
• Encadeamentosimples:
L
I
S
T
A
cauda
cabeça
• Encadeamentoduplo:
L
cabeça
I
S
T
A
cauda
TADLista:OperaçõesUsuais
• UmTADlistapodeserdefinidoatravésdas
seguintesoperações:
ü search(L,k):procuraoprimeiroelemento
comchaveknalistaL.
ü insert(L,x):insereoelementoxnoinícioda
listaL.
ü erase(L,x):removeoelementoxdalistaLe
apagaoitemx.
TADLista:OperaçõesUsuais
• Outrasoperaçõespossíveis:
ü splice(L1,L2):emendaoselementosdalista
L2aofinaldalistaL1.
ü split(L,x):partealistaLemduaslistas,uma
terminandonoelementoxeoutracomeçandono
elementox.
ü merge(L1,L2):juntaduaslistasordenadasem
umasó,tambémordenada.
TADLista:OperaçõesUsuais
• Outrasoperaçõespossíveis:
ü pred(L,x):retornaoelementodaListaLque
precedeoelementox.
ü succ(L,x):retornaoelementodaListaLque
sucedeoelementox.
ListaxVetor
Qualadiferençaentreumalistaeum
vetor?
VantagensxDesvantagens
Quaissãoasvantagense
desvantagensdesteWpode
representação?
ListaEncadeadaSimples(slist)
L
cabeça
I
S
T
A
cauda
ListaEncadeadaSimples(slist)
• Implementaçãopormeiodeponteiros.
L
cabeça
I
S
T
A
cauda
• Quaisseriamasoperaçõesusuaissobreeste
Wpodelista?
ListaEncadeadaSimples(slist)
• Operações:
slist():construtordelistavazia.
~slist():odestrutordalistairáapagartodosos
seuselementos.
push_front(v):insereovalorvnoiníciodalista.
front():acessaoprimeiroelementodalista.
ListaEncadeadaSimples(slist)
• Operações:
insert_after(pos,v):insereovalorvnalista,
apósoelementoqueocupaaposiçãopos.
erase_after(pos):removeoelementoapóso
elementoqueocupaaposiçãopos.
find(v):retornaoelementoquecontémovalor
informado,ounulocasonãoexistaumelemento.
ListaEncadeadaSimples(slist)
• Operações:
clear():apagatodososelementosdalista.
empty():retornaverdadeirosealistaesWvervazia,
casocontrário,retornafalso.
Obs.: Para não nos complicarmos
com os templates por hora, vamos
implementar uma lista encadeada
simplescomnúmerosinteiros.
Atenção:UmaversãouWlizandotemplatespodeserencontradanositedocurso:
hlp://www.dpi.inpe.br/~gribeiro/doku.php?id=wiki:cursos:cap241-2016:aula5estruturas_dados
TADslist:representaçãointerna
• Cadaelementodalistaserárepresentadopela
seguinteestrutura:
structitem
{
intdata;
item*next;
};
data
next
9
ponteirop/próximo
itemdalista
TADslist:representaçãointerna
• Porsuavez,alistaserárepresentadaporuma
classecomumúnicomembrodedados
privado:
classslist
{
...
private:
item*head_;
};
3
7
2
head_:ponteiropara
acabeçadalista.
TADslist:definição
classslist
{
Estruturaaninhada
public:
structitem
{
intdata;
item*next;
};
...
};
TADslist:definição
classslist
{
public:
...
slist();
~slist();
...
};
Construtor
Destrutor
TADslist:definição
classslist
{
public:
...
voidpush_front(intv);
item*front()const;
...
};
TADslist:definição
classslist
{
public:
...
item*insert_after(item*pos,intv);
voiderase_after(item*pos);
item*find(intvalue)const;
...
};
TADslist:definição
classslist
{
public:
...
voidclear();
boolempty()const;
...
};
TADslist:definição
Tornandoestesdoisoperadoresprivados,sem
classslist
fornecerumaimplementação,farácomqueos
{
objetosslistnãopossamsercopiáveis
...
private:
slist(slist&);
slist&operator=(slist&);
private:
C++éumalinguagemondeoidiomadecópiaé
item*head_; algonatural,noentanto,demandaextrema
atençãodoprojeWstadeumaclasse.Vocêsabe
};
comofuncionaessesistemadecópia?
UsandooTADslist
slistl;//criaumalistavazia
l.push_front(2); 2
l.push_front(7); 7
2
l.push_front(3); 3
7
2
l.push_front(5); 5
3
7
l.push_front(9); 9
5
3
2
7
2
UsandooTADslist
slist::item*x=l.find(7);
head_
9
5
3
7
x
if(x)
l.erase_after(x);
head_
9
5
3
7
x
2
UsandooTADslist
x=l.find(5);
head_
9
5
3
7
x
if(x)
x=l.insert_after(x,8);
9
5
8
3
7
head_
x
TADslist:implementação
• slist():construtordelistavazia.
slist::slist()
:head_(nullptr)
{
}
head_
0x0000000000000000
64-bits
TADslist:implementação
• ~slist():odestrutordalistairáapagartodosos
seuselementos.
slist::~slist()
{
clear();
}
head_
9
5
8
head_
3
7
TADslist:implementação
• push_front(intv):insereumelementono
iníciodalista.
voidslist::push_front(intv)
{
head_=newitem{v,head_};
}
Listalcontendo1elemento
head_
l.push_front(7);
newitem{v,head_};
7
2
2
novoelemento
head_
7
2
head_=newitem{v,head_};
TADslist:implementação
• front():acessaoprimeiroelementodalista.
slist::item*slist::front()const
{
returnhead_;
}
head_
7
2
TADslist:implementação
• insert_after(pos,v):insereumelementonalistalogo
apósoutroelemento.
slist::item*
slist::insert_after(item*pos,intv)
{
assert(pos);
item*nn=newitem{v,pos->next};
pos->next=nn;
returnnn;
}
TADslist:implementação
• erase_after(item*pos):removeumelementoapóso
elementoinformado.
voidslist::erase_after(item*pos)
{
assert(pos&&pos->next);
item*dn=pos->next;
pos->next=dn->next;
deletedn;
}
TADslist:implementação
• find(v):retornaoelementoquecontémovalorinformado,
ounulocasonãoexistaumelemento.
slist::item*slist::find(intv)const
{
item*i=head_;
x=l.find(5);
while(i)
head_
9
5
{
if(i->data==v)
i
break;
head_
9
5
i=i->next;
}
i
returni;
}
3
7
3
7
TADslist:implementação
• clear():apagatodososelementosdalista.
voidslist::clear()
{
while(item*i=head_)
{
head_=head_->next;
deletei;
}
}
l.clear();
head_
5
3
7
TADslist:implementação
i
• clear():apagatodososelementosdalista.
5
voidslist::clear()
{
while(item*i=head_)
{
head_=head_->next;
deletei;
}
}
i
3
7
head_
3
i
7
head_
3
i
7
head_
5
i
3
head_
7
TADslist:implementação
• empty():dizsealistaencontra-seounãovazia.
boolslist::empty()const
{
returnhead_==nullptr;
}
Qualoespaçodearmazenamentoda
nossaestruturaslistparaumalista
contendonelementos?
sizeof(T)=kesizeof(T*)=v
f(n)=n*(k+v)+v
supondok==v,f(n)=k(2n+1)
O(n)
Qualacomplexidadeda
operaçãopush_front(v)?
O(1)
Qualacomplexidadeda
operaçãofront(v)?
O(1)
Qualacomplexidadedaoperação
insert_after(pos,v)?
O(1)
Qualacomplexidadeda
operaçãoerase_after(pos)?
O(1)
Qualacomplexidadeda
operaçãofind(v)?
O(n)
Qualseriaacomplexidadedeuma
operaçãocount()queretornasse
onúmerodeelementosdalista?
QuaisestratégiapoderíamosuWlizar
paraimplementarestaoperação?
SemanWvéssemosumponteiroextrapara
acaudadalista,quaisoutrasoperações
poderíamoster?Qualocustodelas?
push_back?,back?,pop_back?
Umalistaencadeadasimplesnos
permiterealizardeformaeficienteuma
travessiasequencialunidirecional.
Quandoprecisamosdeumaestrutura
dinâmicaquepossibiliteatravessia
bidirecional,uWlizamoslistas
duplamenteencadeadas.
ListaDuplamenteEncadeada(list)
L
cabeça
I
S
T
A
cauda
ListaDuplamenteEncadeada(list)
• Implementaçãopormeiodeponteiros.
L
cabeça
I
S
T
A
cauda
• Quaisseriamasoperaçõesusuaissobreeste
Wpodelista?
ListaDuplamenteEncadeada(list)
• Operações:
list():construtordelistavazia.
~list():odestrutordalistairáapagartodososseus
elementos.
push_front(v):insereovalorvnoiníciodalista.
front():acessaoprimeiroelementodalista.
ListaDuplamenteEncadeada(list)
• Operações:
next(x):retornaopróximoelementodalista.
previous(x):retornaoelementoanteriorao
elementoxnalista.
insert(pos,v):insereovalorvnalista,antesdo
elementoqueocupaaposiçãopos.
erase(x):removeoelementox.
ListaDuplamenteEncadeada(list)
• Operações:
find(v):retornaoelementoquecontémovalor
informado,ounulocasonãoexistaumelemento.
clear():apagatodososelementosdalista.
empty():retornaverdadeirosealistaesWvervazia,
casocontrário,retornafalso.
Obs.: Para não nos complicarmos
com os templates por hora, vamos
implementar uma lista duplamente
encadeadaparanúmerosinteiros.
Atenção:UmaversãouWlizandotemplatespodeserencontradanositedocurso:
hlp://www.dpi.inpe.br/~gribeiro/doku.php?id=wiki:cursos:cap241-2016:aula5estruturas_dados
TADlist:representaçãointerna
• Cadaelementodalistaserárepresentadopela
seguinteestrutura:
structitem
{
item*next;
item*prev;
intdata;
};
ponteirop/oitem
anterior
data
9
ponteirop/próximo
itemdalista
TADlist:representaçãointerna
• Porsuavez,alistaserárepresentadaporuma
classecomumúnicomembrodedados
privado:
classlist
{
...
private:
item*head_;
};
3
7
2
head_:ponteiropara
acabeçadalista.
TADlist:definição
classlist
{
Estruturaaninhada
public:
structitem
{
item*next;
item*prev;
intdata;
};
...
};
TADlist:definição
classlist
{
public:
...
list();
~list();
...
};
Construtor
Destrutor
TADlist:definição
classlist
{
public:
...
item*next(item*x)const;
item*previous(item*x)const;
...
};
TADlist:definição
classlist
{
public:
...
voidpush_front(intv);
item*front()const;
...
};
TADlist:definição
classlist
{
public:
...
item*insert(item*pos,intv);
voiderase(item*x);
item*find(intvalue)const;
...
};
TADlist:definição
classlist
{
public:
...
voidclear();
boolempty()const;
...
};
TADlist:definição
Tornandoestesdoisoperadoresprivados,sem
classlist
fornecerumaimplementação,farácomqueos
{
objetoslistnãopossamsercopiáveis
...
private:
list(list&);
list&operator=(list&);
private:
item*head_;
};
UsandooTADlist
listl;//criaumalistavazia
l.push_front(2);
l.push_front(7);
l.push_front(3);
l.push_front(5);
l.push_front(9);
UsandooTADlist
list::item*x=l.find(7);
if(x)
l.erase(x);
UsandooTADlist
x=l.find(5);
if(x)
x=l.insert(x,8);
TADlist:implementação
• list():construtordelistavazia.
list::list()
:head_(nullptr)
{
}
TADlist:implementação
• ~list():odestrutordalistairáapagartodosos
seuselementos.
list::~list()
{
clear();
}
TADlist:implementação
• next(item*x):retornaoelementoseguinteaoelemento
xnalista.
list::item*list::next(item*x)const
{
returnx->next;
}
TADlist:implementação
• previous(item*x):retornaoelementoanteriorao
elementoxnalista.
list::item*list::previous(item*x)const
{
returnx->prev;
}
TADlist:implementação
• push_front(intv):insereumelementono
iníciodalista.
voidlist::push_front(intv)
{
item*nn=newitem{head_,nullptr,v};
if(head_)
head_->prev=nn;
head_=nn;
}
TADlist:implementação
• front():acessaoprimeiroelementodalista.
list::item*list::front()const
{
returnhead_;
}
TADlist:implementação
• insert(item*pos,intv):insereumelementonalista
antesdeoutroelemento.
list::item*list::insert(item*pos,intv)
{
assert(pos);
item*nn=newitem{pos,pos->prev,v};
pos->prev=nn;
if(nn->prev)
nn->prev->next=nn;
else
head_=nn;
returnnn;
}
TADlist:implementação
• erase(item*x):removeoelementoinformado.
Voidlist::erase(item*x)
{
assert(x);
if(x->prev)
x->prev->next=x->next;
else
head_=x->next;
if(x->next)
x->next->prev=x->prev;
deletex;
}
TADlist:implementação
• find(v):retornaoelementoquecontémovalorinformado,
ounulocasonãoexistaumelemento.
list::item*list::find(intv)const
{
item*i=head_;
while(i)
{
if(i->data==v)
break;
i=i->next;
}
returni;
}
TADlist:implementação
• clear():apagatodososelementosdalista.
Voidlist::clear()
{
while(item*i=head_)
{
head_=head_->next;
deletei;
}
}
TADlist:implementação
• empty():dizsealistaencontra-seounãovazia.
boollist::empty()const
{
returnhead_==nullptr;
}
Qualoespaçodearmazenamentoda
nossaestruturalistparaumalista
comnelementos?
sizeof(T)=kesizeof(T*)=v
f(n)=n*(k+2v)+v
supondok==v,f(n)=k(3n+1)
O(n)
Listas:ConsideraçõesFinais
OrdemdosElementos
• Seoselementosdalistaencontram-se
ordenados,aordemlineardalista
correspondeàordemdachavedoelemento
dedados:
– Omenorelementocorrespondeaoelementoda
cabeçadalista.
– Omaiorelementocorrespondeaoelementoda
cauda.
TravessiaBidirecional
• Acrescentandoumponteiroparaacaudada
lista(tail_),numalistaduplamente
encadeadas,poderíamos:
– realizarumatravessiaporqualquerumadas
extremidadesdalista
– Acrescentaroperaçõesparainserçãoeremoção
aofinaldalista.
ListasCirculares
• ListasEncadeadaSimples:
– Podemosadotaraconvençãodequealigação(ponteiro)
doúlWmonóaponteparaoprimeironódalista
head_
9
5
3
7
2
• ListasDuplamenteEncadeadas:
– AligaçãoparaopróximonódoúlWmoelementoaponta
paraoprimeiro;ealigaçãodoelementoanteriornocaso
doprimeiroelementoapontaparaoúlWmo.
head_
9
5
3
7
2
tail_
OutrasEstratégiasdeImplementação
• ElementoSenWnela:
– PodemosuWlizaralgunsobjetosespeciais,
conhecidoscomodummyousen.nelas,para
facilitaraimplementaçãodaslistas.
– Nestecasocriamosumelementoextraquepode
simplificaraescritadasoperações.
– DevemosuWlizaresterecursocombastante
cuidadopoisemumaaplicaçãocomumgrande
númerodepequenaslistasesseespaçoextra
podepenalizarosistema.
OutrasEstratégiasdeImplementação
• Implementaçãodelistaspormeiodearranjos:
– Implementaçãopormeiodevetoresparalelos.
Implementação:vetoresparalelos
items next
0
1
2
3
4
5
6
7
head
0
3
1
4
2
5
6
1
5
9
3
7
2
0
1
2
3
4
5
6
7
dummy spare
1
6
PrimeiroItem:items[next[head]]
SegundoItem:items[next[next[head]]]
spare:marcadordopróximoespaçovago.
dummy:marcadorespecialdofinaldalista.
9
5
cabeça
3
7
2
cauda
Vocêjápensounumbomusoparaa
abstraçãodelistaspormeiodearranjos?
“freelist”
AlocaçãoDinâmicadeMemória
ListasemLinguagensdeProgramação
• Emalgumaslinguagensdeprogramaçãoesta
estruturadedadoséumWpoprimiWvoda
linguagem:
– Lisp,Python,Haskell.
• EmC++,temosestaestruturapormeioda
bibliotecaSTL,escritacomoprópriocoreda
LinguagemC++:
– std::list,std::forward_list
Quizz
Qualoresultadodaseguinte
operação:sizeof(list::item)?
Cuidado:alinhamentoepaddingdas
estruturas!
Pilhas
(Stacks)
Umapilhanadamaisédoqueumalista
ondeasinserções,remoçõeseacessos
ocorremsempreemumaúnica
extremidade.
Pilhas:operações
• UmTADpilhapodeserdefinidoatravésdas
seguintesoperações:
push:insereumnovoitemnotopodapilha.
pop:removeumitemdotopodapilha.
top:retornaoelementonotopodapilha
A
push(P)
P
push(I)
I
P
H
H
L
L
I
I
P
pop()
P
QualapolíWcadeacesso
implementadaporumapilha?
UmapilhaimplementaumapolíWcado
Wpo:oúlWmoaentrarseráoprimeiroa
sair–lastin,firstout(LIFO).
Quaissãoosusosdaestrutura
dedadospilha?
ALinguagemLuaeousodePilhas
Exemplo.lua
c=terralib.Coord2D:new(1.0,2.0)
x=c:getX()
LigaçãoLua<->C++:coord2d.cpp
voidlua_pop(lua_State*L,intn):
popsnelementsfromthestack.
voidlua_pushnumber(lua_State*L,
lua_Numbern):pushesafloatwithvaluen
ontothestack.
staticintCoord2D_getX(lua_State*L)
{
te::gm::Coord2D*c=*(te::gm::Coord2D**)lua_touserdata(L,1);
lua_pushnumber(L,c->x);
return1;
}
Comopodemosimplementar
umaestruturadedadospilha?
Vetores×Apontadores
Pilha:implementaçãopormeiodevetor
• Estaimplementaçãodemanda:
– Umvetorparaositens.
– Marcadordotopodapilha
– NúmeroMáximodeItens
itens
topo
5
tamanho
6
6
5
4
3
2
1
A
H
L
I
P
Discussão
Aula31/03/2015
stack.hpp:implementaçãodepilhas
emC/C++atravésdevetores.
Pilhas:implementaçãopormeiode
apontadores
Atenção:esta
topo
item
A
T
S
I
L
próximo
representaçãoestá
usandoumelemento
senWnelaoudummyou
nil.
Qualacomplexidadedasoperações
sobreumapilha?
• push:insereumnovoitemnotopodapilha.
O(1)
• pop:removeumitemdotopodapilha.
O(1)
• top:retornaoelementonotopodapilha.
O(1)
Filas
(Queues)
Umafilanadamaisédoqueumalista
ondeasinserçõessãofeitasnuma
extremidadeeasremoçõesocorremna
outraextremidade.
Filas:operações
• UmTADfilapodeserdefinidoatravésdasseguintes
operações:
enqueue:enfileiraumnovoitem.
dequeue:removeumitemdoiníciodafila.
first:retornaoprimeiroelementodafila
A
enqueue(F)
F
enqueue(I)
I
F
L
A
I
L
F
dequeue()
I
QualapolíWcadeacesso
implementadaporumafila?
UmafilaimplementaumapolíWcaemqueo
elementoaserremovidoésempreaquele
queentrouprimeiro,ouseja,oprimeiroa
entrarseráoprimeiroasair–firstin,first
out(FIFO).=>ordemdechegada!
Quaissãoosusosdaestrutura
dedadosfila?
Comopodemosimplementar
umaestruturadedadosfila?
VetoresxApontadores
Filas:implementaçãopormeiodearranjos
• Estaimplementaçãodemandatrêsvariáveis:
– Umvetorparaositens.
– Ummarcadordoinciodafilaeoutrodofinal.
• Invariantes:
head_ 0
head_==tail_=>filavazia
head_==tail_+1=>filacheia
tail_ 4
size_ 6
Obs.:Nossafilaserácircular!
q_
0
1
2
3
F
I
L
A
4
5
Filas:implementaçãopormeiodearranjos
• Qualocouidadoespecialquedevemoster
paradisWnguirfilacheiadefilavazia?
– Invariantes:
head_==tail_=>filavazia
head_==tail_+1=>filacheia head_ 0
tail_ 4
size_ 6
Obs.:Nossafilaserácircular!
q_
0
1
2
3
F
I
L
A
4
5
Operação:Enfileira
voidqueue::enqueue(charc)
{
std::size_tpos=(tail_+1)%size;
if(pos==head_)
throwstd::logic_error("Queueoverflow!");
q_[tail_]=c;
tail_=pos;
}
Operação:Desenfileira
charqueue::dequeue()
{
if(head_==tail_)
throwstd::logic_error("Queueunderflow!");
charc=q_[head_];
head_=(head_+1)%size;
returnc;
}
Filas:implementaçãopormeiodearranjos
head_ 0
tail_ 0
0
1
2
3
4
5
enqueue('G')
head_ 0
tail_ 1
0
G
1
2
3
4
5
enqueue('I')
head_ 0
0
1
tail_ 2
G
I
2
3
4
5
Filas:implementaçãopormeiodearranjos
head_ 0
tail_ 2
0
G
1
I
2
3
4
5
enqueue('L')
head_ 0
tail_ 3
0
G
1
I
2
L
3
4
5
enqueue('B')
head_ 0
0
1
2
3
tail_ 4
G
I
L
B
4
5
Filas:implementaçãopormeiodearranjos
head_ 0
tail_ 4
0
G
1
I
2
L
3
B
4
5
enqueue('E')
head_ 0
tail_ 5
0
G
1
I
2
L
3
B
4
E
5
enqueue('R')
(tail_+1)%size_==head_=>FilaCheia!
Obs.:Nossafilateránomáximon-1elementos!
Filas:implementaçãopormeiodearranjos
head_ 0
tail_ 0
0
1
2
3
4
dequeue()
head_==tail_=>FilaVazia!
5
Filas:implementaçãopormeiodearranjos
head_ 0
tail_ 5
0
G
1
I
2
L
3
B
4
E
5
4
E
5
5
dequeue()
head_ 1
tail_ 5
0
G
1
I
2
L
3
B
dequeue()
head_ 2
0
1
2
3
4
tail_ 5
G
I
L
B
E
Filas:implementaçãopormeiodearranjos
head_ 2
tail_ 5
0
G
1
I
2
L
3
B
4
E
5
4
E
5
5
dequeue()
head_ 3
tail_ 5
0
G
1
I
2
L
3
B
dequeue
head_ 4
0
1
2
3
4
tail_ 5
G
I
L
B
E
Filas:implementaçãopormeiodearranjos
head_ 4
tail_ 5
0
G
1
I
2
L
3
B
4
E
5
4
E
5
dequeue()
head_ 5
tail_ 5
0
G
1
I
2
L
3
B
dequeue
head_==tail_=>FilaVazia!
Filas:implementaçãopormeiodearranjos
head_ 4
tail_ 5
0
G
1
I
2
L
3
B
4
E
5
enqueue('R')
head_ 4
tail_ 0
0
G
1
I
2
L
3
B
4
E
5
R
enqueue('T')
head_ 4
0
1
2
3
4
5
tail_ 1
T
I
L
B
E
R
Discussão
queue.hpp:implementaçãodefilas
emC++atravésdevetores.
Filas:implementaçãopormeiodeapontadores
head
item
F
I
L
tail
L
próximo
Discussão
lqueue.hpp:implementaçãodefilas
emC++atravésdeapontadores.
Qualacomplexidadedasoperações
sobreumafila?
• enqueue:enfileira.
O(1)
• dequeue:desenfileira.
O(1)
• first:retornaoelementodoiníciodafila.
O(1)
ConsideraçõesFinais
ConsideraçõesFinais
• Asestruturasvistasnestaaulapossuemamplaaplicaçãona
CiênciadaComputação.
• DiscuWremosdiversosalgoritmosnaspróximasaulasque
precisarãodoapoiodessasestruturas.
• Tambémiremosaprofundarnasestruturasdedadosde
árvores.
• OprojetodabibliotecaSTLdeC++éumdosmelhores
exemplosdousodetécnicasdeprogramaçãoeparadigmas
paradesenvolvimentodeestruturasdedadosgenéricas
eficientes.
ConsideraçõesFinais
AlexanderStepanov
MengLee
DavidMusser
ProjeWstaseDesenvolvedoresdabibliotecaC++Standard
TemplateLibrary(STL)
ReferênciasBibliográficas
ReferênciasBibliográficas
• CORMEN,T.H.;LIESERSON,C.E.;RIVEST,R.L.;
STEIN,C.Introduc<ontoAlgorithms.2ªEdição.
MitPress,2001.
• HOROWITZ,E.;SAHNI,S.;RAJASEKARAN,S.
ComputerAlgorithms.1ªEdição.Computer
SciencePress,1997.769p.
• ZIVIANI,N.ProjetodeAlgoritmos:com
implementaçõesemPASCALeC.2ªEdição.
EditoraThomson,2005.552p.
ReferênciasBibliográficas
• IERUSALIMSCHY,R.;FIGUEIREDO,L.H.;CELES,W.Passinga
LanguagethroughtheEyeofaNeedle.ACMQueue,v.9,n.
5,maio,pp.20-29,2011.
• RAYMOND,E.S.TheLostArtofCStructurePacking.Online.
Disponívelem:<hlp://www.catb.org/esr/structure-packing>.
Acesso:12deAbrilde2016.
• SAKS,D.PaddingandRearrangingStructureMembers.Dr.
Dobb’s,19set.2012.Online.Disponívelem:
hlp://www.drdobbs.com/cpp/padding-and-rearrangingstructure-member/240007649.Acesso:12deAbrilde2016.
ReferênciasBibliográficas
• AlStevensInterviewsAlexStepanov.Dr.Dobb's
Journal.Online.Disponívelem:<
hlp://www.sgi.com/tech/stl/drdobbsinterview.html>.Acesso:12deAbrilde2016.
Exercícios
Exercícios
• E-5.1.EmCeC++existealgumadiferença
práWcaemusarlaçosqueprocessemuma
matrizpelaslinhasoupelascolunas?
• E-5.2.Seestendermosaperguntadoexercício
E-5.1aoscompiladoresFortran,qualseriaa
resposta?
Exercícios
• E-5.3.ParWndodaimplementaçãodelistasencadeadas
simples(slist),disponívelnositedocurso,acrescenteas
seguintesoperações:
remove(v):removedalistaoprimeiroelementoaconterovalor
v.Qualacomplexidadedestaoperação?
splice_after(pos,L):transfereoselementosdalistaLpara
alistaoperada,colocandooselementosdeLapósaposiçãopos.
AlistaLficarávaziaaofinal.Otempodestaoperaçãodeveráser
O(k),ondekrepresentaonúmerodeelementosdalistaL.
reverse():inverteaordemdoselementosdalistaemtempo
O(n).
Atenção:Existemduasversõesdalistaencadeadasimples:umaparanúmerosinteirose
outraparaWposgeraisusandotemplates.Sevocêoptarpelalistadeinteiros,teráque
trocaraimplementaçãopeloWpochar.
Exercícios
•
E-5.4.Implementeumalistaduplamenteencadeadapormeiodeapontadores.
Estalistadeverápossibilitar:
–
–
–
–
–
–
–
–
–
–
–
–
–
–
–
–
Recuperaroprimeiroelemento(front).
RecuperaroúlWmoelemento(back).
Recuperarosucessordoelementox(next).
Recuperaroantecessordoelementox(previous).
Inserirnacabeçadalista(push_front).
inserirnacauda(push_back).
inserirantesdeumaposiçãoespecíficax(insert).
Removerumelementoespecífico(erase).
Removeroprimeiroelemento(pop_front).
RemoveroúlWmoelemento(pop_back).
FundiroselementosdeumalistaL2aofinaldalistaL1(splice).
ParWcionarumalistaLemduaslistas,umaterminandonoelementoxeoutracomeçandono
elementox(split).
Reverteroselementosdalista(reverse).
Juntarduaslistasordenadasemumasó,tambémordenada(merge).
Limparalista(clear).
Dizersealistaéounãovazia(empty).
Atenção:Existemduasversõesdalistaduplamenteencadeada:umaparanúmerosinteiros
eoutraparaWposgeraisusandotemplates.Nenhumadelassuportatodasessasoperações.
Exercícios
• E-5.5.UWlizaroTADPilhaparaimplementaruma
calculadoraaritméWcacomnotaçãopolonesa.
Vocêdeverálerumaexpressãonaformade
stringcomanotaçãoinfixaetransformá-laem
umastringcomanotaçãopós-fixa.AparWrda
notaçãopós-fixa,useumapilhaparateajudara
implementaraavaliaçãodaexpressão.Considere
apenasasoperaçõesaritméWcasbásicas.
• Ex:
– Entrada:5*(((9+8)*(4*6))+7)
– Transformação:598+46**7+*
ExercíciosEspeciais
Aentreganãoéobrigatória!
ExercíciosEspeciais
• E-5.6.Umapilhapermiteinserireremover
elementosapenasnumaextremidade(topoda
pilha).Umafilapermiteinseriremuma
extremidade(cauda)eremoverdaoutra
(cabeça).Projeteeimplementeumdeque
(double-endedqueue)pormeiodearranjos,de
formaapermiWrinserçõeseremoçõesnasduas
extremidas.Asquatrooperaçõesparainserire
removerelementosdosdoisladosdodeque
devemtercomplexidadeO(1).
ExercíciosEspeciais
• E-5.7.ProjeteumalocadordememóriaemC
uWlizandolistasdeespaçovazio.SuaAPIdeveser
formadapelasseguintesfunções:
void*my_malloc(unsignednbytes):
Alocaumblocodenbyteseretornaumponteiroparaoinício
dobloco;
voidmy_free(void*ap):
Liberaumblocodememória.
voidprint_available_mem():
Imprimenatelaalistadeblocosvazios:
ExercíciosEspeciais
• E-5.8.Projeteumalocadordememóriapara
pequenosobjetosemC++.Osblocosde
memóriagerenciadosdevemserdetamanho
fixoecompa‡veiscomotamanhodoobjeto
queuWlizaráessealocador.
Dica:alémdoprojetodoalocador,vocêterá
quesobrecarregarosoperadoresnew,new[],
deleteedelete[]naclassedeseusobjetos.
Fim!
