Pilhas: mudanças entre as edições

De Wiki Cursos IFPR Foz
Ir para navegaçãoIr para pesquisar
Linha 11: Linha 11:


As duas operações primitivas para lidar com pilhas são <ref name="TENENBAUM"/>:
As duas operações primitivas para lidar com pilhas são <ref name="TENENBAUM"/>:
* '''''push''''': Quando um elemento é inserido, ou '''empilhado''', na pilha;
* '''''push''''': Quando um elemento é '''inserido''', ou '''empilhado''', na pilha;
*'''''pop''''': Quando um elemento é extraído, ou '''desempilhado''', da pilha.
*'''''pop''''': Quando um elemento é '''extraído''', ou '''desempilhado''', da pilha.


;Funções para operar com pilhas:
;Funções para operar com pilhas:
Linha 27: Linha 27:
  i = top(s);
  i = top(s);


Não existe um limite máximo para o número de item em uma pilha. Entretanto, se uma tiver um só elemento e ele for extraído, teremos a '''pilha vazia'''. Portanto, antes de utilizar o operador '''pop''', precisamos verificar se a pilha não está vazia.
Não existe um limite máximo para o número de item em uma pilha. Entretanto, se uma pilha tiver um só elemento e ele for extraído, teremos a '''pilha vazia'''. Portanto, antes de utilizar o operador '''pop''', precisamos verificar se a pilha não está vazia.


A operação  
A operação  

Edição das 18h08min de 19 de setembro de 2014

Pilhas

Uma pilha é um conjunto ordenado de itens, na qual novos item podem ser inseridos ou extraídos a partir de seu topo [1].

Uma pilha é um objeto dinâmico, constantemente mutável a partir da inserção ou extração de itens, sempre a partir de seu topo.

Quando um novo item é inserido na pilha, ele passa a ocupar seu topo. Neste caso, o topo é deslocado para cima de modo a corresponder ao novo primeiro elemento. Quando um item é removido, o topo da pilha é deslocado para baixo, para apontar ao novo primeiro elemento.

Operações primitivas com pilhas

As duas operações primitivas para lidar com pilhas são [1]:

  • push: Quando um elemento é inserido, ou empilhado, na pilha;
  • pop: Quando um elemento é extraído, ou desempilhado, da pilha.
Funções para operar com pilhas

Considere uma pilha s e um item i, a função

push(s, i);

insere o item na pilha.

Por sua vez a função

i = pop(s);

extrai um item do topo da pilha.

Outra operação que pode ser utilizada é verificar o item do topo da pilha, sem extrai-lo

i = top(s);

Não existe um limite máximo para o número de item em uma pilha. Entretanto, se uma pilha tiver um só elemento e ele for extraído, teremos a pilha vazia. Portanto, antes de utilizar o operador pop, precisamos verificar se a pilha não está vazia.

A operação

empty(s);

verifica se a pilha está vazia ou não.

Imlementação de pilhas em linguagem C

Antes de programar a solução de um problema usando pilhas, é preciso definir como a pilha será representada na linguagem de programação que estamos utilizando.

Na linguagem C, uma das maneiras de implememtar uma pilha é utilizando vetores. Contudo, pilhas e vetores são tipos de dados diferentes:

  • Uma pilha é um conjunto ordenado de itens de tamanho é variável e, a princípio, não tem limite de tamanho.
  • Um vetor, por sua vez, é um conjunto ordenado de itens, cujo tamanho é fixado na declaração do vetor.

Entretando, podemos utilizar um vetor para implementar uma pilha, desde que este vetor seja declarado suficientemente grande para conter a pilha que pretendemos implementar. Uma extremidade do vetor será o final fixo da pilha, enquanto o topo da pilha se desloca constantemente a medida que elementos são inseridos ou extraídos da pilha[1].

Implementando pilhas com vetores

Uma implementação de uma pilha em C pode ser realizada a partir da declaração de uma estrutura com dois campos[2]:

  • Um vetor de items para armazenar os elementos da pilha;
  • Um inteiro que aponta para o topo da pilha dentro do vetor.

Ver também[3]

Uma pilha de inteiros pode ser declarada como
#define TAM 100
struct pilha {
  int topo;
  int itens[TAM];
};
Depois de declara a variável de pilha no programa principal (struct pilha p) o topo deve ser inicializado com zero (p.topo = 0).
Operação push
Insere item no topo da pilha.
void push(struct pilha *p, int item)
{
   p->itens[p->topo++] = item;
}
Esta operação faz p->itens[p->topo] = item e depois incrementa topo.

Poderia também fazer um controle de erro para verificar se o tamanho da pilha são será ultrapassado:

void push(struct pilha *p, int item)
{
    if (p->topo == TAM) {
        fputs("Erro: overflow\n", stderr);
        abort();
    } else
        p->itens[p->topo++] = item;
}
Operação pop
Extrai item no topo da pilha.
void pop(struct pilha *p)
{
   return p->itens[--p->topo];
}
Esta operação decrementa top e depois retorna p->itens[top].

A operação pop() somente pode ser utilizada se a pilha não estiver vazia. Para isto, verificar antes com a função empty().

Operação top
Retorna o item do topo da pilha, sem extraí-lo.
void top(struct pilha *p)
{
   return p->itens[p->topo];
}
Operação empty
Verifica se a pilha está vazia.
int empty(struct pilha *p)
{
    if (p->topo == 0) 
        return -1;
    else
        return 0;
}

Exemplo de aplicação de pilhas

Referências

  1. 1,0 1,1 1,2 TENENBAUM, A. A.; LANGSAM, Y.; AUGENSTEIN, M.J. Estruturas de dados usando C, capítulo 2: A Pilha, São Paulo: Makron Books, 1995.
  2. Wikipedia: Stack. http://en.wikipedia.org/wiki/Stack_%28abstract_data_type%29#Implementation
  3. FEOFILOFF, p. Projeto de algoritmos em C: Pilhas. http://www.ime.usp.br/~pf/algoritmos/aulas/pilha.html

--Evandro.cantu (discussão) 16h49min de 17 de julho de 2014 (BRT)