Estruturas de Dados. Parte dos slides a seguir são adaptações, extensões e traduções para C dos originais:

Transcrição

1 Estruturas de Dados Pilhas Prof. Ricardo J. G. B. Campello Créditos Parte dos slides a seguir são adaptações, extensões e traduções para C dos originais: disponíveis em cedidos pela Profa. Maria Cristina F. de Oliveira 2 1

2 Pilhas Pilha: lista linear em que inserção e eliminação de elementos só ocorrem em uma das extremidades Tal extremidade é denominada TOPO da pilha D C B A TOPO BASE Dada uma Pilha P = (a 1, a 2,..., a n ), dizemos que a 1 é o elemento na base, a n é o elemento no topo, e a i+1 está acima de a i na pilha 3 O TAD PILHA Uma Pilha armazena elementos de um ou mais tipos Inserções e Remoções seguem o esquema Last-In First-Out Pense nela como uma pilha de pratos ou de livros Operações principais: push(x, P): insere um elemento x no topo da pilha P. pop(p): remove e retorna o elemento que está no topo. Operações auxiliares: top(p): retorna o último elemento inserido, sem retirá-lo da pilha P. size(p): retorna o número de elementos armazenados na pilha P. pilha_vazia(p): indica se a pilha P está vazia ou não

3 Aplicações de Pilhas Aplicações diretas: Histórico de páginas visitadas em um navegador na Web Controle de Desfazer/Refazer ações em um editor de textos Encadeamento de chamadas a métodos ou funções em ambientes de execução, como em Pascal, C ou Java Aplicações indiretas: Estrutura auxiliar para algoritmos Componente de outras estruturas de dados 5 Exemplo: Pilha de Chamadas Um programa executável mantém controle da cadeia de chamadas ativas através de uma Pilha: Por exemplo, pilha de recursão Quando uma rotina é chamada, insere-se na pilha uma frame com: Variáveis locais e valor de retorno. Contador de programa (PC) que mantém a trilha das declarações sendo executadas. Quando uma rotina encerra sua frame é removida da pilha e o controle é passado à rotina no topo da pilha. main() { int i = 5; foo(i); } foo(int j) { int k; k = j+1; bar(k); } bar(int m) { } bar PC = 1 m = 6 foo PC = 3 j = 5 k = 6 main PC = 2 i = 5 6 3

4 Implementação Baseada em Arranjo Uma forma simples de implementar o TAD Pilha é usar arranjos. Adicionamos elementos a partir do início do arranjo. Uma variável topo guarda informação sobre a posição do elemento do topo : Coincide com o tamanho da Pilha se arranjo for indexado a partir de 1. Algoritmo pop(p): se pilha_vazia(p) então retorne nulo senão P.topo P.topo 1 retorne P.S[P.topo + 1] Algoritmo push(x, P) se pilha_cheia(p) então retorne false senão P.topo P.topo + 1 P.S[P.topo] x retorne true S topo 7 Implementação Baseada em Arranjo #define MAX 100 /* Max. Tamanho da Pilha */ #define TRUE 1 #define FALSE 0 #define bool int typedef struct { Tipo_1 chave; /* P. ex. int chave; */ Tipo_2 info; /* P. ex. char info[50] */ } tipo_elem; /* Tipo do Elemento */ typedef struct { int topo; tipo_elem S[MAX+1]; } Pilha; /* Tipo da Pilha */ Pilha P; /* Exemplo de Declaração */ 8 4

5 Implementação Baseada em Arranjo void define(pilha *P){ P->topo = 0; P->S[0].chave = 0; /* Célula não utilizada */ P->S[0].info[0] = '\0'; /* Célula não utilizada */ } /* O(1) */ bool pilha_vazia(pilha *P){ return (P->topo == 0); } /* O(1) */ int size(pilha *P){ return P->topo; } /* O(1) */ 9 Implementação Baseada em Arranjo bool push(tipo_elem x, Pilha *P){ if (P->topo == MAX) return FALSE; /* pilha cheia! */ else { P->topo++; P->S[P->topo] = x; return TRUE; } } /* O(1) */ 10 5

6 Implementação Baseada em Arranjo tipo_elem top(pilha *P){ tipo_elem x; if (pilha_vazia(p)) { x.chave = 0; /* elemento inválido */ x.info[0] = '\0'; /* elemento inválido */ } else x = P->S[P->topo]; return x; } /* O(1) */ 11 Implementação Baseada em Arranjo tipo_elem pop(pilha *P){ tipo_elem x; if (pilha_vazia(p)) { x.chave = 0; /* elemento inválido */ x.info[0] = '\0'; /* elemento inválido */ } else { x = P->S[P->topo]; P->topo--; } return x; } /* O(1) */ 12 6

7 Desempenho e Limitações Desempenho: Seja n o número de elementos na pilha O espaço utilizado (memória) é O(MAX) Cada operação roda em tempo O(1) Limitação: Apenas inserções e remoções no final! O tamanho máximo da pilha deve ser definido a priori e não pode ser alterado a não ser copiando toda a pilha para uma outra, de capacidade maior. 13 Implementação Encadeada Para eliminar a necessidade de prever o tamanho máx. da pilha, utiliza-se uma implementação dinâmica. Encadeamento simples é suficiente: Apenas inserções e remoções no início topo A B C D O espaço utilizado (memória) é O(n) Cada operação roda em tempo O(1) 14 7

8 Implementação Encadeada Por simplicidade, implementaremos a pilha usando a implementação simplesmente encadeada do TAD Lista Logo, assume-se que foram predefinidos os tipos: nodo, tipo_elem, Lista. p. ex. via #include arquivo.h (header) da lista typedef struct { Lista *Lis_din; } Pilha; 15 Implementação Encadeada Pilha *define(void){ Pilha *P; P = malloc(sizeof(pilha)); (P->Lis_din) = Definir(); return P; } /* O(1), pois Definir é O(1) */ 16 8

9 Implementação Encadeada int size(pilha *P){ return Tamanho(P->Lis_din); } /* O(1), pois Tamanho é O(1) */ bool pilha_vazia(pilha *P){ return Lista_vazia(P->Lis_din); } /* O(1), pois Lista_vazia é O(1) */ * Como reescrever pilha_vazia usando size...? 17 Implementação Encadeada void push(tipo_elem x, Pilha *P){ Inserir_frente(x, P->Lis_din); } /* O(1), pois Inserir_frente é O(1) */ tipo_elem pop(pilha *P){ if (!pilha_vazia(p)) return Remover_frente(P->Lis_din); else printf("pilha Vazia!!!"); } /* O(1), pois Remover_frente é O(1) */ 18 9

10 Implementação Encadeada tipo_elem top(pilha *P){ if (!pilha_vazia(p)) return Elemento(P->Lis_din->head); else printf("pilha Vazia!!!"); } /* O(1), pois Elemento é O(1) */ 19 Implementação Estática vs Dinâmica Ambas realizam todas as ops. em tempo O(1). Implementação estática seqüencial: mais simples Implementação dinâmica: mais apropriada para pilhas cujo tamanho não pode ser antecipado ou é muito variável 20 10

11 Exemplo de Aplicação Avaliação de Expressões Aritméticas: Uma representação conveniente do ponto de vista computacional é de interesse Por exemplo, para o desenvolvimento de compiladores A notação tradicional (infixa) é ambígua Por exemplo: A * B - C / D =? Demanda regras de prioridade ou uso de parênteses Outras notações são mais convenientes 21 Exemplo de Aplicação Notação Polonesa (prefixa): Operadores aparecem imediatamente antes dos operandos. Especifica quais operadores devem ser calculados e a ordem. Por esse motivo, dispensa o uso de parênteses. Exemplo: * A B / C D = (A*B) (C/D) Notação Polonesa Reversa (posfixa): Operadores aparecem após os operandos. Exemplo: A B * C D / = (A*B) (C/D) 22 11

12 Exemplo de Aplicação Algoritmo (Avaliação de Expressões) Para Notação Polonesa Reversa: Percorre a expressão seqüencialmente empilhando operandos até encontrar um operador Quando encontra um operador desempilha o número correspondente de operandos calcula e empilha o valor resultante 23 Exemplo de Aplicação Expressão: A B / D E * + A

13 Exercícios 1. Implemente um procedimento recursivo que remova todos os elementos de uma pilha. Esse procedimento só pode acessar a pilha através das operações definidas no TAD Pilha. 2. Implemente a seguinte função: Pilha *copia(pilha *P); que receba um ponteiro para uma Pilha P1 e retorne um ponteiro para outra Pilha P2 alocada dinamicamente em memória e cujos elementos são cópias de P1, na mesma ordem da base para o topo. Essa função deve usar, como variáveis locais, apenas 2 pilhas (nenhuma outra variável). 25 Bibliografia A. M. Tenembaum et al., Data Structures Using C, Prentice-Hall, 1990 M. T. Goodrich & R. Tamassia, Data Structures and Algorithms in C++/Java, John Wiley & Sons, 2002/2005 N. Ziviani, Projeto de Algoritmos, Thomson, 2a. Edição, 2004 J. L. Szwarcfiter & L. Markenzon, Estruturas de Dados e seus Algoritmos, LTC, 1994 Schildt, H. "C Completo e Total", 3a. Edição, Pearson,