ESTRUTURAS DE DADOS (LEI, LM, LEE) PROGRAMAÇÃO III (LTSI)

ESTRUTURAS DE DADOS (LEI, LM, LEE)
PROGRAMAÇÃO III (LTSI)
Universidade da Beira Interior, Departamento de Informática
Hugo Pedro Proença, 2012/2013

Pilhas e Filas
Dois dos tipos de objectos mais comummente usados em algoritmos
computacionais são as “Pilhas” e “Filas”.
Ambos são especificações de um tipo mais genérico: as listas
ligadas.
Normalmente, uma lista ligada tem associado um critério de ordenação
que determina a posição dos elementos na lista.
A posição de cada elemento nas “Pilhas” e “Filas” é determinada pela
ordem pela qual os elementos são introduzidos no conjunto.
Ao remover um elemento de uma lista, é comum eliminar todos os
recursos a ele associados.
Ao contrário, nas “Pilhas” e “Filas” é usual a remoção do elemento do
conjunto para posterior colocação noutro, não se efectuado por esta
razão a libertação de recursos.

Fila (Queue)
Uma fila é uma lista ordenada em que…
Todas as inserções se fazem na última posição da lista.
Todas as remoções se fazem da primeira posição da lista.
O primeiro elemento a ser inserido na fila é também o
primeiro a ser processado.
São também designadas de “FIFO” (First In, First Out).
Na ciência computacional são tipicamente utilizadas
para manter informação temporariamente para futuro
processamento.
Neste contexto, as filas desempenham funções de buffers.

Pilhas (Stack)
Uma pilha é uma lista ordenada em que…
Todas as inserções se fazem na primeira posição da lista.
Todas as remoções se fazem da primeira posição da lista.
O último elemento a ser inserido na pilha é o primeiro
a ser processado.
São também designadas por LIFO (Last In, First Out).
São bastante utilizadas em sistemas computacionais.
Por exemplo, os sisteams operativos implementam-nas para
o tratamento de “interrupts” e chamadas ao sistema.

Fila: inserção (Função push())
Exemplo:
F 1 3 5 8
nv 4

Pilha: inserção (Função push())
Exemplo:
P
F 1 3 5 8
el

Fila e Pilha: remoção (Função pop())
Exemplo:
F 1 3 5 8
nv 4

Pilhas e Filas: remoção
Tal como atrás referido, uma das (poucas)
diferenças fundamentais das Pilas e Filas
relativamente ao tipo mais geral (Listas) é a não
eliminação dos nós removidos.
Ao invés, é devolvido um apontador para o elemento
que acabou de ser retirado do conjunto.
Desta forma, é possível a transição de um elemento
entre vários conjuntos (Pilhas ou Filas).

Pilhas e Filas: remoção
Esta característica conduz a algumas alterações ao
nível da implementação da função pop().
Por um lado, a cabeça da Pilha || Fila é alterada,
pelo que tem que ser sempre devolvido um apontador
para a posição actualizada.
Por outro, desejamos receber um apontador para o
elemento removido da Pilha||Fila.
As funções não permitem o retorno de mais que uma
variável…

Pilhas e Filas: remoção
A solução está na passagem de parãmetros por
referência.
Alguns dos parãmetros que utilizamos na chamada à
função pop() são “bi-direccionais”.
Parãmetros de entrada e de saída.
Protótipo:
Nodo* pop(Nodo **p);
Apontador para o elemento removido
Cabeça da pilha||fila actualizada

Duplo **
Tome-se o seguinte exemplo:
void funcao(int a){
a=a+1; //”variável” alterada na função
}
Ao chamar a função, por exemplo a partir do
main(){
int b=5;
funcao(b);
printf(“B=%d\n”,b);
}
Como é óbvio, uma vez que um parãmetro é uma cópia de uma
variável, o valor de “b” não é alterado na função “main”.

Duplo **
Repare-se agora na semelhança deste exemplo com a situação anterior
Nodo* funcao(Nodo *a){ //cabeça da pilha||fila
}
Nodo *el=a;
if (a==NULL)
return(NULL);
a=a->nseg; //o apontador “a” é alterado
el->nseg=NULL;
return(el);
Ao chamar a função, por exemplo a partir do
main(){
}
Nodo *b=NULL, *el;
…
el=funcao(b);
…
“el” fica com o valor de retorno da função. Tudo OK!
Mas “b” (apontador para a cabeça da lista), não é alterado na função main(), pelo que manteria o
mesmo valor, isto é, apontaría para o mesmo local.

Duplo **
Exemplo 2: Atente-se na seguinte situação, onde o problema
anterior não se verifica.
void funcao(Nodo *a){
a->chave=10;
}
Ao chamar a função a partir do main(), o valor do atributo
chave sería alterado.
main(){
}
Nodo *b=NULL;
…
funcao(b);
…
A única cópia existente é a do apontador “b”

Duplo **
Solução: O parãmetro passado na função “pop” é o de
“um apontador para um apontador para um nodo”.
Assim sendo, as alterações efectuadas no “apontador para
nodo” têm repercurssões fora da função.
Nodo* pop(Nodo **a){
Nodo *el=*a;
if (*a==NULL)
return(NULL);
(*a)=(*a)->nseg;
el->nseg=NULL;
}
return(el);
Parãmetro
Passível de alteração
a
Nodo

Duplo **
Para chamar a função pop(), deveremos ter em
atenção esta mudança no tipo de parãmetro.
main(){
}
Nodo *p=NULL, *el;
… //Inserções, …
el=pop(&p);
…
O endereço de “p” aponta para um local que
aponta para um nodo.
Necessita de ser libertado, ou colocado noutra pilha||fila

Pilhas: push()
O prótótipo para a função de inserção em pilhas é
semelhante à função “insereInicio()” das listas
ligadas:
Nodo* push(Nodo *p, Nodo *nv){
if (p==NULL)
return(nv);
nv->nseg=p;
return(nv);
}

Filas: push()
O prótótipo para a função de inserção em filas é
semelhante à função “insereFim()” das listas ligadas:
Nodo* push(Nodo *f, Nodo *nv){
Nodo *aux=f;
if (aux==NULL)
return(nv);
while(aux->nseg!=NULL)
aux=aux->nseg;
aux->nseg=nv;
return(f);
}

Pilhas e Filas: Exercício
Implemente o comportamento previsto para a
inserção numa fila apenas usando pilhas.
Protótipo: Nodo* pushfila(Nodo*f, Nodo *nv);
Inversamente, implemente o comportamento
previsto para uma pilha apenas usando filas.
Protótipo: Nodo* pushPilha(Nodo*p, Nodo *nv);