Você está na página 1de 18

Lista de exerccios Estrutura de dados 2015.

2
Aluno: Washington Klbson Lima da Silva - 11324573

1 Implementao das pilhas, da sequencial e da pilha encadeada, e das


funes bsicas, nas letras abaixo implementarei o restante das funes
pedidas na questo.

PILHA _SEQ.h

#ifndef PILHA_SEQ_H_INCLUDED
#define PILHA_SEQ_H_INCLUDED
#define MAX 100
typedef struct{
int dados[MAX]; /** Vetor de dados da Pilha */
int topo; /** Topo da Pilha */
}tPilha;

void cria(tPilha *pilha);


int vazia(tPilha pilha);
int cheia(tPilha pilha);
int tamanho(tPilha pilha);
int top(tPilha pilha, int *dado);
int push(tPilha *pilha, int dado);
int pop(tPilha *pilha, int *dado);

#endif // PILHA_SEQ_H_INCLUDED

PILHA_SEQ.c

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_SEQ.h"

void cria (tPilha *pilha){


pilha->topo=-1;
}

int vazia (tPilha pilha){


if(pilha.topo==-1)
return 1;
else
return 0;
}

int cheia (tPilha pilha){


if(pilha.topo==MAX-1)
return 1;
else
return 0;
}

int tamanho (tPilha T){


return(T.topo+1);
}

int top (tPilha pilha, int *dado){


if(pilha.topo==-1){
return 0;
}

else {
*dado=pilha.dados[pilha.topo];
return 1;
}
}

int push (tPilha *pilha, int dado){


if(pilha->topo==MAX-1){
return 0;
}

else {
pilha->topo++;
pilha->dados[pilha->topo]=dado;
return 1;
}
}

int pop(tPilha *pilha, int *dado){


if (pilha->topo==-1){
return 0;
}

else {
*dado = pilha->dados[pilha->topo];
(pilha->topo)--;
return 1;
}
}

E agora a pilha encadeada

PILHA_ENC.h

#ifndef PILHA_ENC_H_INCLUDED
#define PILHA_ENC_H_INCLUDED
#define MAX 100

typedef struct no{


char dados;
struct no *prox;
}tNo;

typedef struct{
tNo *topo;
int n;
}tPilha;

void cria (tPilha *pilha);


int vazia (tPilha pilha);
int tamanho (tPilha pilha);
int top (tPilha pilha, char *dado);
int push (tPilha *pilha, char dado);
int pop (tPilha *pilha, char *dado);

#endif // PILHA_ENC_H_INCLUDED

PILHA_ENC.c

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_ENC.h"

void cria (tPilha *pilha){


pilha->topo = NULL;
pilha->n=0;
}

int vazia (tPilha pilha){


return (pilha.n==0);
}

int tamanho (tPilha pilha){


return pilha.n;
}

int top (tPilha pilha, char *dado){


if (vazia(pilha)){
return 0;
}

else {
*dado=pilha.topo->dados;
return 1;
}
}
int push (tPilha *pilha, char dado){
tNo *novoNo =(tNo*)malloc(sizeof(tNo));
if(novoNo==NULL) return 0;
novoNo->dados=dado;
novoNo->prox=pilha->topo;
pilha->topo=novoNo;
(pilha->n)++;
return 1;
}

int pop (tPilha *pilha, char *dado){

if (vazia(*pilha)) return 0;
tNo *aux = pilha->topo;
*dado = aux->dados;
pilha->topo = (pilha->topo)->prox;
(pilha->n)--;
free(aux);
return 1;
}

void exibe (tPilha pilha){

tNo *p=pilha.topo;
int i=pilha.n;
while(p!=NULL){
printf("Posicao %d, Conteudo %c\n", i, p->dados);
p=p->prox;
i--;
}
}

void inverte (tPilha *pilha){


tPilha pilhaB;
cria(&pilhaB);
char aux;
while(pilha->topo!=NULL){
pop(pilha, &aux);
push(&pilhaB, aux);
}
(*pilha) = pilhaB;
}

int remover(tPilha *pilha, char dado){


tPilha pilhaB;
cria(&pilhaB);
char b;
int num=0;
while(pilha->topo!=NULL){
if(pilha->topo->dados!=dado){
pop(pilha, &b);
push(&pilhaB, b);
}

else {
pop(pilha, &b);
num++;
}
}

inverte(&pilhaB);
(*pilha)=pilhaB;
return num;
}

int pilhasIguais(tPilha pilha1, tPilha pilha2){


if(pilha1.n!=pilha2.n) return 0; //tamanhos diferentes
while (pilha1.topo!=NULL){
if(pilha1.topo->dados!=pilha2.topo->dados) return 0;//pilhas diferentes
else {
pilha1.topo=pilha1.topo->prox;
pilha2.topo=pilha2.topo->prox;
}
}

return 1;
}

void destroi(tPilha *pilha){


char a;
while(!vazia(*pilha)){
pop(pilha, &a);

}
}

a) Uma funo para exibir a pilha. Esta funo deve exibir o tamanho da pilha
e todos os seus elementos;

PILHA_SEQ.h

void exibe(tPilha pilha);

PILHA_SEQ.c

void exibe (tPilha pilha){


int i;
for(i=pilha->topo; i>=0; i--){
printf("item %d de %d == valor: %d\n", i, pilha.topo, pilha.dados[i]);
}
}

PILHA_ENC.h

void exibe (tPilha pilha);

PILHA_ENC.c

void exibe (tPilha pilha){

tNo*p=pilha->topo;
int i=0;
while(p!=NULL){
printf("Posio %d, Conteudo %c\n", i, p->dados);
p=p->prox;
i++;
}
}

b) Uma funo para inverter uma pilha encadeada;

PILHA_ENC.h

void inverte (tPilha *pilha);

PILHA_ENC.c

void inverte (tPilha *pilha){


tPilha pilhaB;
cria(&pilhaB);
char dado;
while(pilha->topo!=NULL){
pop(pilha, &dado);
push(&pilhaB, dado);
}
*pilha=pilhaB;
}

c) Uma funo que elimina todas as ocorrncias de um determinado


elemento em uma pilha, retornando o nmero de elementos eliminados.

PILHA_SEQ.h
int remover (tPilha *pilha, int a);

PILHA_SEQ.c

int remover (tPilha *pilha, int a){


tPilha aux;
cria(&aux);
int dado;
int i;
int num=0;
for (i=pilha->topo; i>=0; i--){
if (pilha->dados[i]!=a){
pop(pilha, &dado);
push(&aux, dado);
}
else{
pop(pilha, &dado);
num++;
}
}
inverte(&aux);
(*pilha)=aux;
return num;
}

PILHA_ENC.h

int remover (tPilha *pilha, char dado);

PILHA_ENC.c

int remover(tPilha *pilha, char dado){

tPilha pilhaB;
cria(&pilhaB);
char b;
int num=0;
while(pilha->topo!=NULL){
if(pilha->topo->dados!=dado){
pop(pilha, &b)
push(&pilhaB, b);
}
else {
pop(pilha, &b);
num++;
}
}
inverte(&pilhaB);
(*pilha)=pilhaB;
return num;
}
d) Uma funo que recebe duas pilhas e verifica se so iguais;

PILHA_SEQ.h

int pilhasIguais (tPilha pilha1, tPilha pilha2);

PILHA_SEQ.c

int pilhasIguais (tPilha pilha1, tPilha pilha2){


if (pilha1->topo!=pilha2->topo) return 0; //tamanho diferente
for (i=pilha1->topo; i>=0; i--){
if(pilha1->dados!=pilha2->dados) return 0;
}
return 1;
}

PILHA_ENC.h

int pilhasIguais (tPilha pilha1, tPilha pilha2);

PILHA_ENC.c

int pilhasIguais(tPilha pilha1, tPilha pilha2){

if(pilha1->n!=pilha2->n) return 0; //tamanhos diferentes


while (pilha1->topo!=NULL){
if(pilha1->topo->dados!=pilha2->topo->dados) return 0;//pilhas diferentes
else {
pilha1.topo=pilha1.topo->prox;
pilha2.topo=pilha2.topo->prox;
}
}
return 1;
}

e) Uma funo para remover todos os elementos de uma pilha, ou seja,


destruir a pilha.

PILHA_SEQ.h

void destroi (tPilha *pilha);

PILHA_SEQ.c

void destroi(tPilha *pilha){


pilha->topo = -1;
}
PILHA_ENC.h

void destroi (tPilha *pilha);

PILHA_ENC.c

void destroi(tPilha *pilha){

char a;
while(!vazia(*pilha)){
pop(pilha, &a);
}
}

2 Crie um mdulo main que teste todas as funcionalidades/operaes


sobre pilhas implementadas na questo 1.

Main.c *Lista Sequencial*

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_SEQ.h"
//#include "PILHA_ENC.h"
/**MAIN SEQUENCIAL*/
int main()
{
tPilha pilha1;
cria(&pilha1);
printf("Cheia: %d / Vazia: %d /Tamanho: %d\n", cheia(pilha1),vazia(pilha1),
tamanho(pilha1));
push(&pilha1, 11);
push(&pilha1, 13);
push(&pilha1, 15);
push(&pilha1, 18);
push(&pilha1, 19);
push(&pilha1, 20);
push(&pilha1, 21);
exibe(pilha1);
printf("Cheia: %d / Vazia: %d /Tamanho: %d\n", cheia(pilha1), vazia(pilha1),
tamanho(pilha1));
return 0;
}

Main.c //Lista Encadeada

#include <stdio.h>
#include <stdlib.h>
//#include "PILHA_SEQ.h"
#include "PILHA_ENC.h"
/*Main ENCADEADA*/
int main()
{
tPilha pilha1, pilha2, pilha3;
char data1, data2, data3;
cria(&pilha1);
cria(&pilha2);
cria(&pilha3);
push(&pilha1, 'a');
push(&pilha1, 'b');
push(&pilha1, 'c');
push(&pilha1, 'd');
push(&pilha1, 'e');
push(&pilha2, 'a');
push(&pilha2, 'b');
push(&pilha2, 'c');
push(&pilha2, 'd');
push(&pilha2, 'e');
push(&pilha3, 'x');
push(&pilha3, 'y');
push(&pilha3, 'z');
push(&pilha3, 'k');
push(&pilha3, 'l');
push(&pilha3, 'm');
exibe(pilha1);
//pop(&pilha1, &data1);
//push(&pilha2, data1);
exibe(pilha2);
printf("%s\n", (pilhasIguais(pilha1, pilha2) ? "Pilhas iguais" : "Pilhas diferentes"));
printf("Pilha1: %s\n", (vazia(pilha1) ? "Pilha vazia" : "Pilha nao-vazia"));
printf("Pilha2: %s\n", (vazia(pilha2) ? "Pilha vazia" : "Pilha nao-vazia"));
printf("Tamanho1: %d.\n",tamanho(pilha1));
printf("Tamanho2: %d.\n",tamanho(pilha2));
printf("Tamanho3: %d.\n",tamanho(pilha3));
top(pilha1, &data1);
top(pilha2, &data2);
top(pilha3, &data3);
printf("Topo1:%c\nTopo2:%c\nTopo3:%c\n", data1, data2, data3);
inverte(&pilha1);
inverte(&pilha3);
exibe(pilha1);
remover(&pilha2, 'e');
remover(&pilha3, 'k');
exibe(pilha2);
exibe(pilha3);
destroi(&pilha2);
exibe(pilha2);
pop(&pilha3, &data3);
pop(&pilha1, &data1);
exibe(pilha1);
exibe(pilha3);
return 0;
}

3) Implemente um programa que analise uma expresso matemtica e


identifique se os elementos separadores de abertura [, { e ( so
encerrados de forma correta com os elementos separadores de
encerramento ), } e ].

PILHA_SEQ.h

#ifndef PILHA_SEQ_H_INCLUDED
#define PILHA_SEQ_H_INCLUDED
#define MAX 100

typedef struct{
char dados[MAX]; /** Vetor de dados da Pilha */
char topo; /** Topo da Pilha */
}tPilha;

void cria(tPilha *pilha);


int vazia(tPilha pilha);
int cheia(tPilha pilha);
int tamanho(tPilha pilha);
int top(tPilha pilha, char *dado);
int push(tPilha *pilha, char dado);
int pop(tPilha *pilha, char *dado);
void exibe(tPilha pilha);

#endif // PILHA_SEQ_H_INCLUDED

PILHA_SEQ.c

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_SEQ.h"

void cria (tPilha *pilha){


pilha->topo=-1;
}

int vazia (tPilha pilha){


if(pilha.topo==-1)
return 1;
else
return 0;
}

int cheia (tPilha pilha){


if(pilha.topo==MAX-1)
return 1;
else
return 0;
}

int tamanho (tPilha T){


return(T.topo+1);
}

int top (tPilha pilha, char *dado){


if(pilha.topo==-1){
return 0;
}

else {
*dado=pilha.dados[pilha.topo];
return 1;
}
}

int push (tPilha *pilha, char dado){


if(pilha->topo==MAX-1){
return 0;
}

else {
pilha->topo++;
pilha->dados[pilha->topo]=dado;
return 1;
}
}

int pop(tPilha *pilha, char *dado){


if (pilha->topo==-1){
return 0;
}

else {
*dado = pilha->dados[pilha->topo];
(pilha->topo)--;
return 1;
}
}

void exibe (tPilha pilha){


int i;
for(i=pilha.topo; i>=0; i--){
printf("item %d de %d == valor: %d\n", i, pilha.topo, pilha.dados[i]);
}
}
MAIN.c

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_SEQ.h"
#include <string.h>

char c[50];

int validar(){
tPilha pilha1;
cria(&pilha1);
int i=0;
char del, topo;
while(c[i] != '\0')
{

top(pilha1, &topo);
switch(c[i])
{
case '{': push(&pilha1, c[i]);
break;
case '[': push(&pilha1, c[i]);
break;
case '(': push(&pilha1, c[i]);
break;
case '}': if(topo == '{') pop(&pilha1, &del); else return 0;
break;
case ']': if(topo == '[') pop(&pilha1, &del); else return 0;
break;
case ')': if(topo == '(') pop(&pilha1, &del); else return 0;
break;
}
i++;
}
return (vazia(pilha1));
}

int main()
{

char *expressao[5];
int i;
for(i = 0; i < 5; i++){
expressao[i] = (char*)malloc(100);
}
expressao[0] = "2 * ( 3 [ 4+ { 2 + 3 }] )";
expressao[1] = "2 * { 3 ( 4 + [ 2 + 3 ] ) }";
expressao[2] = "2 * ( 3 [ 4+5 ) ]";
expressao[3] = "2 + 5 * 35";
expressao[4] = "[3 + 5 x (2 - 4)]{";
for(i = 0; i < 5; i++){
printf("\n\nVerificacao da string %d..", i);
strcpy(c, expressao[i]);
printf("\nExpressao %s", validar()? "VALIDA" : "INVALIDA" );
}
}

4) Escreva um programa que use uma pilha para determinar se uma string
um palndromo (isto , tem a mesma leitura no sentido normal e no sentido
inverso). O programa deve ignorar espaos em branco, pontuao e
caracteres especiais.

PILHA_ENC.h

#ifndef PILHA_ENC_H_INCLUDED
#define PILHA_ENC_H_INCLUDED
#define MAX 100

typedef struct no{


char dados;
struct no *prox;
}tNo;

typedef struct{
tNo *topo;
int n;
}tPilha;

void cria (tPilha *pilha);


int vazia (tPilha pilha);
int tamanho (tPilha pilha);
int top (tPilha pilha, char *dado);
int push (tPilha *pilha, char dado);
int pop (tPilha *pilha, char *dado);
void exibe (tPilha pilha);
void inverte (tPilha *pilha);
int remover (tPilha *pilha, char dado);
int pilhasIguais (tPilha pilha1, tPilha pilha2);
void destroi (tPilha *pilha);

#endif // PILHA_ENC_H_INCLUDED

PILHA_ENC.c

#include <stdio.h>
#include <stdlib.h>
#include "PILHA_ENC.h"

void cria (tPilha *pilha){


pilha->topo = NULL;
pilha->n=0;
}

int vazia (tPilha pilha){


return (pilha.n==0);
}
int tamanho (tPilha pilha){
return pilha.n;
}

int top (tPilha pilha, char *dado){


if (vazia(pilha)){
return 0;
}

else {
*dado=pilha.topo->dados;
return 1;
}
}

int push (tPilha *pilha, char dado){

tNo *novoNo =(tNo*)malloc(sizeof(tNo));


if(novoNo==NULL) return 0;
novoNo->dados=dado;
novoNo->prox=pilha->topo;
pilha->topo=novoNo;
(pilha->n)++;
return 1;
}

int pop (tPilha *pilha, char *dado){

if (vazia(*pilha)) return 0;
tNo *aux = pilha->topo;
*dado = aux->dados;
pilha->topo = (pilha->topo)->prox;
(pilha->n)--;
free(aux);
return 1;
}

void exibe (tPilha pilha){


tNo *p=pilha.topo;
int i=pilha.n;
while(p!=NULL){
printf("Posicao %d, Conteudo %c\n", i, p->dados);
p=p->prox;
i--;
}
}

void inverte (tPilha *pilha){


tPilha pilhaB;
cria(&pilhaB);
char aux;
while(pilha->topo!=NULL){
op(pilha, &aux);
push(&pilhaB, aux);
}
(*pilha) = pilhaB;
}

int remover(tPilha *pilha, char dado){


tPilha pilhaB;
cria(&pilhaB);
char b;
int num=0;
while(pilha->topo!=NULL){
if(pilha->topo->dados!=dado){
pop(pilha, &b);
push(&pilhaB, b);
}
else {
pop(pilha, &b);
num++;
}
}
inverte(&pilhaB);
(*pilha)=pilhaB;
return num;
}

int pilhasIguais(tPilha pilha1, tPilha pilha2){


if(pilha1.n!=pilha2.n) return 0; //tamanhos diferentes
while (pilha1.topo!=NULL){
if(pilha1.topo->dados!=pilha2.topo->dados) return 0;//pilhas diferentes
else {
pilha1.topo=pilha1.topo->prox;
pilha2.topo=pilha2.topo->prox;
}
}
return 1;
}

void destroi(tPilha *pilha){


char a;
while(!vazia(*pilha)){
pop(pilha, &a);
}
}

MAIN.c

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include "PILHA_ENC.h

int palindromo (char *cadeia) {


int palindromo = 1, i = 0;
char dado;
tPilha pilha1;
cria(&pilha1);
while (cadeia[i] != '\0') {
if (isalpha(cadeia[i])){
push(&pilha1, cadeia[i]);
}
i++;
}

for (i=0; i<strlen(cadeia); i++) {


if (cadeia[i] != ' ') {
pop(&pilha1, &dado);
if (cadeia[i] != dado) palindromo = 0;
}
}

return palindromo;
}

int main (){

char * expressao[10];
int i;

for(i = 0; i < 5; i++)


expressao[i] = (char*)malloc(100);

expressao[0] = "paralelepipedo";
expressao[1] = "o...vo";
expressao[2] = "arara";
expressao[3] = "gente";
expressao[4] = "matam";
expressao[5] = "ana";
expressao[6] = "seres";
expressao[7] = "verme";
expressao[8] = "jipe";
for(i = 0; i < 9; i++)
printf("\nExpressao %s: %s", expressao[i], palindromo(expressao[i]) ?
"Eh palindromo" : "Nao eh palindromo" );
}