PCO001

Aula 03 – TAD Pilha

Adaptado do material do Prof. Laercio

Baldochi
 Pilha
Estrutura de Dados do Tipo Pilha
 Pilha

Uma pilha é útil para modelar situações

onde é preciso "guardar vários
elementos" e "lembrar" sempre do último
elemento guardado

(L I F O - Last In, First Out)

 Estrutura de Dados - Pilha
DEFINIÇÃO:

A Pilha (Stack) é uma estrutura linear de dados que

pode ser acessada somente por uma das extremidades
para inserção e remoção de dados.
Segue a política de inserção/remoção chamada LIFO
(Last In/First Out):
• novos elementos são sempre inseridos no "topo" da pilha;
• o único elemento que pode ser retirado da pilha em um dado
momento é o elemento que estiver no topo.
 Pilha - Exemplo
Problema: Em um dado momento da execução de um processo, uma
função X é chamada. Durante a execução de X, encontra-se a chamada
para a função Y. O processo pára a execução de X e passa a executar
Y. Quando termina a execução de Y, como o processo sabe o exato
ponto em que parou a função X?

Solução: A cada chamada (call) da função Y empilha-se (“guardar para

mais tarde”) o endereço de memória da função X de onde ocorreu a
chamada para a função Y. A cada “return de uma determinada função”
desempilha-se (“lembra”) o último endereço armazenado. A execução
continua, então, a partir desse endereço desempilhado.
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &C - 1102
1014 &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &C - 1102
1014 &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &C - 1102
1014 &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &C - 1102
1014 &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1002
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
Stack Pointer &C - 1102
1012 return;
1013 } &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
Stack Pointer &C - 1102
1012 return;
1013 } &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
Stack Pointer &C - 1102
1012 return;
1013 } &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
Stack Pointer &C - 1102
1012 return;
1013 } &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1008
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1010
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1010
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1010
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1010
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
Stack Pointer &D - 1102
1013 } &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
Stack Pointer &C - 1102
1013 } &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
Stack Pointer &C - 1102
1013 } &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
Stack Pointer &C - 1102
1013 } &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
Stack Pointer &B - 1011
1014 &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1003
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1004
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1004
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1004
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014 Stack Pointer &main - 1004
memória
 TAD - exemplo
1100 void C(void) {
1000 int main (void) {
1001 printf(“main\n”); 1101 printf("C");
1002 C( ); 1102 D( );
1003 B( ); 1103 return;
1004 D( ); 1104 }
1005 return 0; 1105 void D(void) {
1006 } 1106 printf("D");
1007 void B(void) { 1107 return;
1008 C( ); 1108 }
1009 printf("B");
1010 D( );
1011 C( );
1012 return;
1013 }
1014
Stack Pointer memória
 Pilha - Como Utilizar

Para manipular uma Pilha, deve-se observar os

seguintes procedimentos:

• Criar (inicializar) a Pilha

• Realizar as operações:
– Inserção
– Remoção
– Consulta
 O TAD Pilha
O TAD Pilha deve conter as seguintes funcionalidades:

create(&p): cria uma pilha vazia p

push (&p,v): empilha o valor da variável v na pilha p
pop(&p,&v) : desempilha da pilha p e retorna em v o
valor do elemento que estava no topo da pilha p
e = top(p): retorna o valor do elemento do topo da pilha
p, sem desempilhar esse elemento da pilha
s = isEmpty(p): s recebe TRUE (1) se a pilha p estiver
vazia, e FALSE (0), caso contrário
 Pilha

Implementação de Pilha Estática

 Pilha - Implementação Estática
#include <stdio.h> pilha
itens[9]
#define TRUE 1 itens[8]
#define FALSE 0 itens[7]
#define TAM_PILHA 10 itens[6]
#define VAZIA -1 itens[5]
itens[4]
struct stack_t itens[3]
{ itens[2]
int itens[TAM_PILHA];
itens[1]
int topo;
itens itens[0]
};
typedef struct stack_t pilha; topo
 Pilha - Implementação Estática
int main(void)
{
int i;
itens[9]
pilha p1;
create(&p1); itens[8]
if (isEmpty(p1)) itens[7]
printf(“\n pilha vazia”);
else itens[6]
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{ itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ p1
int i;
itens[9]
pilha p1;
create(&p1); itens[8]
if (isEmpty(p1)) itens[7]
printf(“\n pilha vazia”);
else itens[6]
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{ itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ p1
int i;
itens[9]
pilha p1;
create(&p1); itens[8]
if (isEmpty(p1)) itens[7]
printf(“\n pilha vazia”);
else itens[6]
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{
void create(pilha *s)
{ itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); s->topo=VAZIA; topo = -1
} }
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ p1
int i;
itens[9]
pilha p1;
create(&p1); itens[8]
if (isEmpty(p1)) itens[7]
printf(“\n pilha vazia”);
else itens[6]
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i); int isEmpty(pilha s)
while(! isEmpty(p1)) { itens[1]
{ if (s.topo==VAZIA) itens[0]
pop(&p1,&i); return TRUE;
printf(“\n desempilha: %d”, i); return FALSE; topo = -1
} }
return 0;
}
 Pilha - Implementação Estática
int main(void) int push(pilha *s, int d)
{ {
p1
int i; if (s->topo==TAM_PILHA -1) itens[9]
pilha p1; return FALSE;
create(&p1); s->topo++; itens[8]
if (isEmpty(p1)) s->itens[s->topo]=d; itens[7]
printf(“\n pilha vazia”); return TRUE;
else itens[6]
}
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 0
}
return 0;
}
 Pilha - Implementação Estática
int main(void) int push(pilha *s, int d)
{ {
p1
int i; if (s->topo==TAM_PILHA-1) itens[9]
pilha p1; return FALSE;
create(&p1); s->topo++; itens[8]
if (isEmpty(p1)) s->itens[s->topo]=d; itens[7]
printf(“\n pilha vazia”); return TRUE;
else itens[6]
}
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 1
}
return 0;
}
 Pilha - Implementação Estática
int main(void) int push(pilha *s, int d)
{ {
p1
int i; if (s->topo==TAM_PILHA-1) itens[9]
pilha p1; return FALSE;
create(&p1); s->topo++; itens[8]
if (isEmpty(p1)) s->itens[s->topo]=d; itens[7]
printf(“\n pilha vazia”); return TRUE;
else itens[6]
}
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
printf(“processo inválido”, i);
3 itens[2]
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 2
}
return 0;
}
 Pilha - Implementação Estática
int main(void) int push(pilha *s, int d)
{ {
p1
int i; if (s->topo==TAM_PILHA-1) itens[9]
pilha p1; return FALSE;
create(&p1); s->topo++; itens[8]
if (isEmpty(p1)) s->itens[s->topo]=d; itens[7]
printf(“\n pilha vazia”); return TRUE;
else itens[6]
}
printf(“\n pilha com dados”); itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); 4 itens[3]
else
printf(“processo inválido”, i);
3 itens[2]
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 3
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ int pop(pilha *s, int *d) p1
int i; {
if (isEmpty(*s))
itens[9]
pilha p1;
create(&p1); return FALSE; itens[8]
if (isEmpty(p1)) *d=s->itens[s->topo]; itens[7]
printf(“\n pilha vazia”); s->topo--;
else return TRUE; itens[6]
printf(“\n pilha com dados”); } itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); 4 itens[3]
else
printf(“processo inválido”, i);
3 itens[2]
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 3
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ int pop(pilha *s, int *d) p1
int i; {
if (isEmpty(*s))
itens[9]
pilha p1;
create(&p1); return FALSE; itens[8]
if (isEmpty(p1)) *d=s->itens[s->topo]; itens[7]
printf(“\n pilha vazia”); s->topo--;
else return TRUE; itens[6]
printf(“\n pilha com dados”); } itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
printf(“processo inválido”, i);
3 itens[2]
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 2
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ int pop(pilha *s, int *d) p1
int i; {
if (isEmpty(*s))
itens[9]
pilha p1;
create(&p1); return FALSE; itens[8]
if (isEmpty(p1)) *d=s->itens[s->topo]; itens[7]
printf(“\n pilha vazia”); s->topo--;
else return TRUE; itens[6]
printf(“\n pilha com dados”); } itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) 2 itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 1
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ int pop(pilha *s, int *d) p1
int i; {
if (isEmpty(*s))
itens[9]
pilha p1;
create(&p1); return FALSE; itens[8]
if (isEmpty(p1)) *d=s->itens[s->topo]; itens[7]
printf(“\n pilha vazia”); s->topo--;
else return TRUE; itens[6]
printf(“\n pilha com dados”); } itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{ 1 itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = 0
}
return 0;
}
 Pilha - Implementação Estática
int main(void)
{ int pop(pilha *s, int *d) p1
int i; {
if (isEmpty(*s))
itens[9]
pilha p1;
create(&p1); return FALSE; itens[8]
if (isEmpty(p1)) *d=s->itens[s->topo]; itens[7]
printf(“\n pilha vazia”); s->topo--;
else return TRUE; itens[6]
printf(“\n pilha com dados”); } itens[5]
for(i=1;i<=4;i++)
if (push(&p1,i))
itens[4]
printf(“\n conseguiu empilhar %d”, i); itens[3]
else
itens[2]
printf(“processo inválido”, i);
while(! isEmpty(p1)) itens[1]
{ itens[0]
pop(&p1,&i);
printf(“\n desempilha: %d”, i); topo = -1
}
return 0;
}
 Exercício 1

• Utilize o TAD pilha estática para avaliar a corretude

de expressões aritméticas do tipo
{[(a+b)+(c–d)]/(e*f)}/g

• Seu programa deve conter uma função que recebe

uma string contendo a expressão aritmética e retorna
true (1) caso o uso de parênteses, chaves e
colchetes esteja correto e false (0), caso contrário
 Exercício 1

• Sugestão

int verificaExp (char *str, pilha *p){

int i, tam;
tam = strlen(str);
for (i=0; i<tam; i++)
if(str[i]==‘{‘ || str[i]==‘[‘ || str[i]==‘(‘)
push(p, str[i]);
...
 Pilha
Implementação Dinâmica
 Pilha - Implementação Dinâmica

A implementação dinâmica consiste em:

• uma Pilha que só ocupe memória quando houver
algum item armazenado
• cada elemento da Pilha é representado por um
nó, formado pelo conteúdo e um endereço para
outro nó
• o processo de inserção consiste em armazenar
memória para o nó e ligá-lo ao anterior
• o processo de remoção consiste em remover o
vínculo e liberar memória.
 Pilha - Implementação Dinâmica
#define TRUE 1
#define FALSE 0
pilha
struct no
quant
{
int dado; topo
struct no *prox;
};

struct pilha_t
{ prox prox
struct no *topo;
dado dado
int quant;
};
nó nó
typedef struct pilha_t pilha;
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i))
exit(0);
while(!isEmpty(p1))
{
pop(&p1,&i);
printf(“\n Pilha: %d”, i);
}
return 0;
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i))
exit(0);
void create(pilha *s)
while(!isEmpty(p1))
{ {
pop(&p1,&i); s->topo=NULL;
printf(“\n Pilha: %d”, i); s->quant=0;
} }
return 0;
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int isEmpty(pilha s)
exit(0); {
while(!isEmpty(p1)) if (s.inicio
(s.topo ====NULL)
NULL)
{ return TRUE;
pop(&p1,&i); return FALSE;
printf(“\n Pilha: %d”, i); }
}
return 0;
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0); struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
aux->prox = s->topo;
printf(“\n Pilha: %d”, i);
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
aux
printf(“\n Pilha: %d”, i); aux->prox = s->topo;
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
aux
printf(“\n Pilha: %d”, i); aux->prox = s->topo;
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return (FALSE);
pop(&p1,&i); aux->dado = d;
aux
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return (FALSE);
pop(&p1,&i); aux->dado = d;
aux
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0); struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return (FALSE);
pop(&p1,&i); aux->dado = d;
aux->prox = s->inicio;
printf(“\n Pilha: %d”, i); 1
s->inicio = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return (FALSE);
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->inicio; 1
s->inicio = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
struct no *aux;
while(!isEmpty(p1)) aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->inicio; 1
s->inicio = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i);aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux==NULL) return (FALSE);
pop(&p1,&i); aux->dado=d;
printf(“\n Pilha: %d”, i); aux->prox= s->topo; 1
s->topo =aux;
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i);aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux = (struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} returnTRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i);aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->topo =aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
if (!push(&p1, i)) int push(pilha *s, int d)
{
exit(0);
while(!isEmpty(p1))
struct no *aux; 2
aux=(struct no *)malloc(sizeof(struct no));
{ if (aux == NULL) return FALSE;
pop(&p1,&i); aux->dado = d;
printf(“\n Pilha: %d”, i); aux->prox = s->topo; 1
s->inicio = aux;
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux = s->topo;
s->topo = (s->topo)->prox;
pop(&p1,&i); *d = aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return TRUE;
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return (FALSE); 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo==NULL) return (FALSE); 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados"); 4
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1); 3
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE; 2
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux); 1
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo == NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux);
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo ==NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux);
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
aux
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
int pop(pilha *s, int *d)
if (!push(&p1, i)) {
exit(0); struct no *aux;
while(!isEmpty(p1)) if (s->topo==NULL) return FALSE;
{ aux= s->topo;
s->topo =(s->topo)->prox;
pop(&p1,&i); *d=aux->dado;
printf(“\n Pilha: %d”, i); free(aux);
} return(TRUE);
return 0; }
}
 Pilha - Implementação Dinâmica
int main(void) p1
{
int i;
pilha p1;
create(&p1);
if (isEmpty(p1))
printf(“\n Pilha Vazia“);
else
printf("\n Pilha com Dados");
for(i=1;i<=4;i++)
if (!push(&p1, i))
exit(0);
while(!isEmpty(p1))
{
pop(&p1,&i);
printf(“\n Pilha: %d”, i);
}
return 0;
}
 Exercício 2

• Palíndromos são palavras que tem o mesmo

significado quando lidas da esquerda para a direita
ou da direita para a esquerda. Utilizando o TAD pilha
dinâmica, implemente uma função que receba uma
string e verifique se a mesma é um palíndromo.
Utilize sua função num programa que lê palavras e
informa se as mesmas são ou não palíndromos.