Estruturas de Dados Lista 2: soluções J. L. Rangel 1. Suponha que uma pilha é representada através de um vetor vet e de um inteiro num. As declarações podem ser #define MAX 100 int vet[max], num; Escreva uma função push que se recusa a acrescentar um elemento à pilha se não houver espaço suficiente no vetor vet, e, nesse caso, imprime uma mensagem apropriada de erro. void push(int i){ if (num<max) vet[num++]=i; else { printf(">>> Erro: overflow na pilha!!!\n"); printf("%d nao foi empilhado!!!\n",i); 2. Com as mesmas declarações de (1), imagine que resolvemos separar as duas funções da função pop, usando duas funções, int top(void); void pop1(void); ficando para top a função de dizer qual é o elemento do topo da pilha, e para pop1 a função de retirar este elemento, sem devolver nenhum resultado. (Este arranjo seria usado quando queremos ver o elemento do topo antes de resolver retirá-lo de lá.) Escreva as funções top e pop1. Temos, em pilha1.h, /* top e pop1 substituem a velha pop */ int top(void); void pop1(void); e, em pilha1.c, /* top não desempilha */ int top(void) { return vet[num-1]; /* pop1 só desempilha */ void pop1(void){ num--; Além disso, na aplicação xpilha1.c, as chamadas de pop devem ser substituídas: Estruturas de Dados J.L. Rangel 1
while(!vazio()) { printf("%d ", top()); pop1(); printf("\n"); 3. Adapte as funções de (1) e de (2) para o caso em que o tipo PILHA é declarado por #define MAX 100 struct pilha { int vet[max], num; ; typedef struct pilha PILHA; Temos: void push(pilha *p, int i){ if (p->num<max) p->vet[p->num++]=i; else { printf(">>> Erro: overflow na pilha!!!\n"); printf("%d nao foi empilhado!!!\n",i); int top(pilha *p){ return p->vet[p->num-1]; void pop1(pilha *p){ p->num--; int vazio(pilha *p){ return p->num==0; A aplicação também deve ser reescrita, uma vez que a função pop foi substituída por top e pop1 na interface pilha2.h 4. Redefina as operações do tipo PILHA, ou seja, init, push, pop, vazia e show quando o tipo PILHA é declarado por #define MAX 100 struct pilha { int vet[max], num; ; typedef struct pilha *PILHA; (Note que neste caso, o tipo PILHA já é definido como o endereço da estrutura que contém a pilha propriamente dita.) A principal alteração é nos cabeçalhos das funções, com a retirada da estrela (*). Os cabeçalhos em pilha2.h passam a ser Estruturas de Dados J.L. Rangel 2
void push(pilha p, int i); int pop(pilha p); int vazio(pilha p); void show(pilha p); Note que as referências a p->vet e a p->num não precisam ser alteradas, porque o tipo do parâmetro p continua sendo struct { *. Além disso, como uma declaração PILHA p; não aloca espaço para a pilha propriamente dita (ou seja a estrutura struct pilha), isto deve ser feito por uma chamada à função init, que pode ser: PILHA init(void) { PILHA p = (PILHA) malloc(sizeof(struct pilha)); p->num=0; return p; A alteração no cabeçalho de init é necessária porque o valor inicial de cada variável PILHA deve ser dado por esta função. 5. Suponha que vamos implementar uma pilha de caracteres usando uma lista encadeada, com as declarações typedef struct no NO, *PT; struct no { char elem; PT prox; ; typedef PT PILHA; Redefina as operações do tipo PILHA, adaptadas para este caso, em que os elementos da pilha são caracteres. A solução é semelhante a pilha3.h/pilha3.c. Mostraremos apenas as alterações no cabeçalho das operações, adaptando pilha3.h. /* pilha3.h adaptado para pilha de char */ typedef struct no *PILHA; struct no{ char elem; PILHA prox; ; void init(pilha *p); void push(pilha *p, char i); char pop(pilha *p); int vazio(pilha *p); void show(pilha *p); Estruturas de Dados J.L. Rangel 3
6. Idem, supondo que vamos usar operações top e pop1 em vez de pop, como em (2). Novamente, vamos mostrar apenas as alterações no cabeçalho das operações, adaptando pilha3.h. /* pilha3.h adaptado para pilha de char */ typedef struct no *PILHA; struct no{ char elem; PILHA prox; ; void init(pilha *p); void push(pilha *p, char i); char top(pilha *p); void pop(pilha *p); int vazio(pilha *p); void show(pilha *p); 7. Idem, para uma pilha de elementos do tipo struct info *, sendo o tipo struct info declarado por struct info { char nome[80]; int matricula; ; Vamos apresentar duas soluções completas. Solução 1: neste caso, o tipo struct info será conhecido do programador da aplicação, e as operações push e pop vão tratar valores do tipo struct info *. Os arquivos são pinfo1.h, pinfo1.c (interface e implementação da pilha) e xpinfo1.c (um exemplo de aplicação) Arquivo: pinfo1.h /* pinfo1.h */ /* tipo pilha de struct info * */ typedef struct info { char nome[80]; int matricula; INFO, *PINFO; typedef struct no *PILHA; /* tipo struct no sera' definido em pinfo1.c */ void init(pilha *p); Estruturas de Dados J.L. Rangel 4
void push(pilha *p, PINFO pi); PINFO top(pilha *p); void pop1(pilha *p); int vazia(pilha *p); void show(pilha *p); /* cria um NO com nome=n e matricula=m, e retorna endereco */ PINFO criainfo(char *n, int m); Arquivo: pinfo1.c /* pinfo1.c */ #include "pinfo1.h" #include <stdio.h> #include <string.h> typedef struct no NO, *PT; struct no{ PINFO elem; PT prox; ; void init(pilha *p) { *p=null; /* auxiliar */ PT cria(pinfo pi, PT px) { PT p=(pt)malloc(sizeof(no)); p->elem=pi; p->prox=px; return p; void push(pilha *p, PINFO pi) { *p=cria(pi,*p); /* assume que pilha nao esta' vazia */ PINFO top(pilha *p) { return (*p)->elem; void pop1(pilha *p) { PT q=*p; *p=q->prox; free(q); Estruturas de Dados J.L. Rangel 5
int vazia(pilha *p) { return *p==null; void show(pilha *p) { PT q; printf("show: "); for (q=*p; q!=null; q=q->prox) printf("[%s:%d] ",q->elem->nome, q->elem->matricula); printf("\n"); PINFO criainfo(char *n, int m) { PINFO pi=(pinfo)malloc(sizeof(info)); strcpy(pi->nome,n); pi->matricula=m; return pi; Arquivo: xpinfo1.c /* xpinfo1.c */ #include <stdio.h> #include "pinfo1.h" int main(void) { PILHA p1; PINFO pi; init(&p1); push(&p1,criainfo("maria",23)); push(&p1,criainfo("marcelo",27)); push(&p1,criainfo("rodolfo",33)); show(&p1); while (!vazia(&p1)) { pi=top(&p1); printf("[%s,%d]\n",pi->nome,pi->matricula); pop1(&p1); return 0; Solução 2: neste caso, o tipo struct info não será conhecido do programador da aplicação, e as operações push e pop vão tratar valores dos tipos char * (nomes) e int (matrículas). Os arquivos são pinfo2.h, pinfo2.c (interface e implementação da pilha) e xpinfo2.c (um exemplo de aplicação) Arquivo: pinfo2.h /* pinfo2.h */ /* tipo pilha de struct info * */ typedef struct no *PILHA; /* tipo struct no sera' definido em pinfo1.c */ Estruturas de Dados J.L. Rangel 6
void init(pilha *p); /* push recebe como entrada nome n e matricula m */ void push(pilha *p, char *n, int m); /* top fornece como saidas nome n e matricula *m */ void top(pilha *p, char *n, int *m); void pop1(pilha *p); int vazia(pilha *p); void show(pilha *p); Arquivo: pinfo2.c /* pinfo2.c */ #include "pinfo2.h" #include <stdio.h> #include <string.h> typedef struct info { char nome[80]; int matricula; INFO, *PINFO; typedef struct no NO, *PT; struct no{ PINFO elem; PT prox; ; /* cria um NO com nome=n e matricula=m, e retorna endereco */ PINFO criainfo(char *n, int m); void init(pilha *p) { *p=null; /* auxiliar */ PT cria(pinfo pi, PT px) { PT p=(pt)malloc(sizeof(no)); p->elem=pi; p->prox=px; return p; /* push recebe como entrada nome n e matricula m */ void push(pilha *p, char *n, int m) { *p=cria(criainfo(n,m),*p); Estruturas de Dados J.L. Rangel 7
/* top assume que pilha nao esta' vazia */ /* top fornece como saidas nome n e matricula *m */ void top(pilha *p, char *n, int *m) { strcpy(n,(*p)->elem->nome); *m=(*p)->elem->matricula; void pop1(pilha *p) { PT q=*p; *p=q->prox; free(q); int vazia(pilha *p) { return *p==null; void show(pilha *p) { PT q; printf("show: "); for (q=*p; q!=null; q=q->prox) printf("[%s:%d] ",q->elem->nome, q->elem->matricula); printf("\n"); PINFO criainfo(char *n, int m) { PINFO pi=(pinfo)malloc(sizeof(info)); strcpy(pi->nome,n); pi->matricula=m; return pi; Arquivo: xpinfo2.c /* xpinfo2.c */ #include <stdio.h> #include "pinfo2.h" int main(void) { PILHA p1; char n[80]; int m; init(&p1); push(&p1,"maria",23); push(&p1,"marcelo",27); push(&p1,"rodolfo",33); show(&p1); while (!vazia(&p1)) { top(&p1,n,&m); printf("[%s,%d]\n",n,m); pop1(&p1); Estruturas de Dados J.L. Rangel 8
return 0; 8. Suponha uma maquina de calcular que trabalha apenas com números não negativos, e que tem apenas as quatro operações: soma, subtração, produto e divisão inteira. A máquina tem 16 teclas, representadas pelos caracteres: 0 1 2 3 4 5 6 7 8 9 + - * / C E onde C representa clear, e E representa enter, que é usada indicar que vai ser fornecido entrado um número. A máquina usa notação polonesa sufixo, aquela em que o operador vem depois dos operandos. Escreva um programa que usa uma pilha de inteiros para simular a máquina: cada caracter que entra é tratado, e a resposta é o conteúdo da pilha da máquina. Inicialmente, a pilha da máquina está vazia. As ações correspondentes a cada caracter são: i=0, 9 troque o valor x do topo da pilha por x*10+i E empilhe um 0 op=+,-,*,/ tire dois elementos y e x do topo da pilha, e empilhe x op y C esvazia a pilha. Por exemplo, se as entradas fossem sucessivamente E 9 0 E 2 0 E 1 5 E 1 3 - * E 5 + / a pilha teria sucessivamente os seguintes conteúdos: (inicial) [ ] E [ 0 ] 9 [ 9 ] 0 [ 90 ] E [ 90 0 ] 2 [ 90 2] 0 [ 90 20 ] E [ 90 20 0 ] 1 [ 90 20 1 ] 5 [ 90 20 15 ] E [ 90 20 15 0 ] 1 [ 90 20 15 1 ] 3 [ 90 20 15 13 ] - [ 90 20 2 ] * [ 90 40 ] E [ 90 40 0 ] 5 [ 90 40 5 ] + [ 90 45 ] / [ 2 ] indicando o resultado 2 de 90 20 15 13 - * 5 + /, ou seja, (90/((20*(15-13))+5)) na notação habitual A solução usa pilha3.h/pilha3.c do Capítulo 4, substituindo a aplicação por calc.c, mostrado a seguir: /* calc.c */ /* usa a pilha definida por pilha3.h/pilha3.c, no Capitulo 4 */ #include "pilha3.h" Estruturas de Dados J.L. Rangel 9
/* transforma digito em seu valor c deve ser um digito: 0, 1,... 9 */ int valor(char c) { return c-'0'; /* '0'=48 */ /* simula maquina com entrada s */ void maquina(char *s) { PILHA p; int x,y; int i=0; init(&p); printf(" "); show(&p); while (s[i]!='\0') { switch(s[i]) { case 'C': init(&p); break; case 'E': push(&p,0); break; case '+': y=pop(&p); x=pop(&p); push(&p,x+y); break; case '-': y=pop(&p); x=pop(&p); push(&p,x-y); break; case '*': y=pop(&p); x=pop(&p); push(&p,x*y); break; case '/': y=pop(&p); x=pop(&p); push(&p,x/y); break; default: /* deve ser um digito */ x=valor(s[i]); y=pop(&p); push(&p,y*10+x); printf("[%c] ",s[i]); show(&p); i++; Estruturas de Dados J.L. Rangel 10
int main(void) { /* entrada exemplo */ char ent[]="e90e20e15e13-*e5+/"; maquina(ent); return 0; Note que a função show de pilha3.c mostra o conteúdo da pilha na ordem inversa da apresentada no enunciado do exercício. 9. Suponha que uma pilha é declarada por typedef struct no NO, *PT; struct no { char elem; PT prox; ; typedef PT PILHA; para representar uma pilha de caracteres através de uma lista encadeada. Escreva uma função com protótipo int conta(pilha p); que tem como resultado o número de elementos da pilha. Na realidade, esta função conta o número de nós em uma lista encadeada qualquer. int conta(pilha p) { int i=0; PT q=p; while (q!=null) { i++; q=q->prox; return i; Uma solução recursiva poderia ser int conta(pilha p) { if (p==null) return 0; /* else */ return conta(p->prox) +1; 10. Suponha uma pilha de caracteres, cuja interface está no arquivo pilha.h, cujo conteúdo é typedef struct no *PILHA; PILHA init(void); void push(pilha *p, char i); char pop(pilha *p); int vazia(pilha p); void show(pilha p); Escreva um programa que lê uma cadeia s, empilha os caracteres de s em uma pilha p, retira os caracteres de p para uma outra cadeia t, de forma que os caracteres de t são os mesmos caracteres de s em forma invertida. Finalmente, o programa imprime s e t. Estruturas de Dados J.L. Rangel 11
(Para testar este programa, será necessário terminar a implementação da pilha (ou seja, o arquivo pilha.c), completando as declarações de struct no e das funções.) Podemos ter #include "pilha.h" int main(void) { char s[80], t[80]; PILHA p=init(); int i=0; printf(">"); scanf("%s",s); while (s[i]!='\0') { push(&p,s[i]); i++; i=0; while (!vazia(p)) { t[i]=pop(&p); i++; t[i]='\0'; /* para fechar t */ printf("original: %s\ninvertida: %s\n,s,t); return 0; (abr 00) Estruturas de Dados J.L. Rangel 12