-
-
Save gtcarlos/3970756 to your computer and use it in GitHub Desktop.
| #include <stdio.h> | |
| #include <stdlib.h> | |
| struct pilha | |
| { | |
| int info; | |
| struct pilha *prox; | |
| }; | |
| int inserir(struct pilha **fila,struct pilha **fim,int n) | |
| { | |
| if(*fila==NULL) | |
| { | |
| (*fila)=(*fim)=(struct pilha*)malloc(sizeof(struct pilha)); | |
| if (*fila==NULL) | |
| { | |
| return -1; | |
| } | |
| (*fila)->info=n; | |
| (*fila)->prox=NULL; | |
| return (0); | |
| } | |
| struct pilha *aux; | |
| aux=(struct pilha*)malloc(sizeof(struct pilha)); | |
| if(aux==NULL) | |
| { | |
| return (-1); | |
| } | |
| aux->info=n; | |
| aux->prox=NULL; | |
| (*fim)->prox=aux; | |
| (*fim)=aux; | |
| return (0); | |
| } | |
| int transformar(struct pilha **fila,struct pilha **pilha) | |
| { | |
| if(*pilha==NULL) | |
| { | |
| (*pilha)=(struct pilha*)malloc(sizeof(struct pilha)); | |
| if (*pilha==NULL) | |
| { | |
| return -1; | |
| } | |
| (*pilha)->info=(*fila)->info; | |
| (*pilha)->prox=NULL; | |
| (*fila)=(*fila)->prox; | |
| struct pilha *aux; | |
| while((*fila)!=NULL) | |
| { | |
| aux=(struct pilha*)malloc(sizeof(struct pilha)); | |
| if(aux==NULL) | |
| { | |
| return (-1); | |
| } | |
| aux->info=(*fila)->info; | |
| aux->prox=(*pilha); | |
| (*pilha)=aux; | |
| (*fila)=(*fila)->prox; | |
| } | |
| } | |
| return (0); | |
| } | |
| main() | |
| { | |
| int n,x,y,t=0;; | |
| struct pilha *fila,*fim,*pilha; | |
| fila=fim=NULL; | |
| pilha=NULL; | |
| while(t!=4) | |
| { | |
| printf("Digite um numero para inserir na fila: "); | |
| scanf("%d",&n); | |
| x=inserir(&fila,&fim,n); | |
| t++; | |
| } | |
| printf("\nTRANSFORMANDO FILA EM PILHA ...\n\n"); | |
| y=transformar(&fila,&pilha); | |
| printf("Pilha transformada:\n\n"); | |
| while(pilha!=NULL) | |
| { | |
| printf("%d ",pilha->info); | |
| pilha=pilha->prox; | |
| } | |
| free(fila); | |
| printf("\n"); | |
| } |
Esse é o código do Collection.h
typedef struct Collection_ {
int size;
int elements[MAX];
} Collection;
resolvido
/********************************************************************************************************************
- PRIMEIRA AVALIAÇÃO
- Use este código para realizar a tarefa. Foram feitas as configurações iniciais com define´s e include´s, foram
- declaradas as funções iniciais da fila (funções a serem implementadas), mas não foi feito nenhuma parte da pilha.
- O objetivo da aplicação é receber um conjunto de strings em uma fila e ir retirando os elementos da fila para
- inverte-los. Para realizar a inversão (função inversor) você deve usar uma pilha.
- Dicas:
- a) uma string é um vetor de caracteres terminadas por \0.
- b) se você inserir os elementos de um vetor em uma pilha e depois retira-los, eles virão na ordem inversa.
- Com o código pronto estes testes devem ser executados com sucesso (sem mensagens indicando erro).
*********************************************************************************************************************/
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////// Alunos: Murilo e Ramom /////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
#define MAX 20
#include "collection.h"
#include <stdio.h>
#include <strings.h>
#include<stdlib.h>
#define TRUE 0
#define FALSE 1
Collection criar_fila();
int insere(Collection *fila, char *textoAInserir);
int retira(Collection *fila, char *textoRemovido);
int inversor(char *textoOriginal, char *textoInvertido);
//----- Esta parte do código não pode ser alterada ------
int main() {
char textos[20][20] = { "Abertura", "Continuo", "Contador", "Marcado", "Automovel", "Gentileza", "Verdade", "Fermento", "Teclado", "Barbeiro", "Treinamento", "Dinamismo", "Homenagem", "Levantar", "Integral"};
char textosInvertidos[20][20] = { "arutrebA", "ounitnoC", "rodatnoC", "odacraM", "levomotuA", "azelitneG", "edadreV", "otnemreF", "odalceT", "oriebraB", "otnemanierT", "omsimaniD", "meganemoH", "ratnaveL", "largetnI"};
char *textoOriginal = (char *)malloc(20 * sizeof(char));
char *textoInvertido = (char *)malloc(20 * sizeof(char));
Collection fila = criar_fila();
int i, j;
//Inserção de dez elementos na fila
for(j = 0; j < 10; j++) {
insere(&fila, textos[j]);
}
i = 0;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
//Inseção de mais cinco elementos na fila
for(j = 10; j < 15; j++) {
insere(&fila, textos[j]);
}
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
printf("texto[10] = %s\n", textos[10]);
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
printf("texto[11] = %s\n", textos[11]);
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
i++;
retira(&fila, textoOriginal) == TRUE ? printf("[%d] Texto retirado da fila com sucesso [%s]\n", i, textoOriginal) : printf("[%d] Erro na retirada do texto da fila\n", i);
strcmp(textoOriginal, textos[i]) == TRUE ? printf("Primeiro texto correto\n") : printf("Erro no Primeiro texto retirado\n");
inversor(textoOriginal, textoInvertido) == TRUE ? printf("[%d] Texto invertido com sucesso [%s]\n", i, textoInvertido) : printf("[%d] Erro na inversao do texto\n", i);
strcmp(textoInvertido, textosInvertidos[i]) == TRUE ? printf("Inversao do primeiro texto correto\n") : printf("Erro na inversao do primeiro texto retirado\n");
system ("pause");
return 0;
}
//----------- Final da parte do código que não pode ser alterada ---------
Collection criar_fila() {
Collection texto;
texto.Tamanho = 0;
return texto;
}
int insere(Collection *fila, char *textoAInserir) {
if(fila->Tamanho == MAX) return FALSE;
strcpy(fila->elements[fila->Tamanho], textoAInserir);
fila->Tamanho++;
return TRUE;
}
int retira(Collection *fila, char *textoRemovido) {
if(fila->Tamanho == 0) return FALSE;
strcpy(textoRemovido, fila->elements[0]);
int i;
for(i = 0; i < fila->Tamanho-1; i++)
strcpy(fila->elements[i], fila->elements[i+1]);
fila->Tamanho--;
return TRUE;
}
// criando a pilha
Pilha criar_pilha() {
Pilha inicio;
inicio.Tamanho = 0;
return inicio;
}
/*
Rotina que faz a inserção de elementos na pilha
A função não retorna valor algum
*/
void push(Pilha *pilha, char texto) {
pilha->elements[pilha->Tamanho] = texto;
pilha->Tamanho++;
}
/*
Rotina que retira elementos da pilha
O elemento retirado sempre é o que está no topo
*/
char pop(Pilha *pilha) {
return pilha->elements[--pilha->Tamanho];
}
//Rotina inversor
int inversor(char *textoOriginal, char *textoInvertido) {
Pilha pilha = criar_pilha();
int i = 0;
while(textoOriginal[i] != '\0') {
push(&pilha, textoOriginal[i]);
i++;
}
int j;
for(j = 0; i > 0; i--, j++) {
textoInvertido[j] = pop(&pilha);
}
textoInvertido[j] = '\0';
return TRUE;
}
arquivo #include "collection.h"(tem que salvar, como: Collection.h, arquivo separado porem na mesma pasta").
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////// Alunos: Murilo e Ramom /////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
typedef struct Collection_ {
int Tamanho;
int elements[MAX][MAX];
} Collection;
typedef struct Pilha {
int Tamanho;
int elements[MAX];
} Pilha;
como vou poder transformar esse código em fila e depois em pilha devolvendo as string invertidas?
/********************************************************************************************************************
*********************************************************************************************************************/
//fila tem dois pontos de conexao
//pilha tem somente um ponto de conexao mais restrito, ponto de entrada é o mesmo ponto da saida caracteristica da pilha inverte o que foi inserido.
//caracteristica da atividade insersao na fila é de um arrey string, na pilha é caracter a caracter e no sair sai invertido.
//na hora de colocar na pilha nao começa pelo ultimo e na hora de retirar colocar /0 para ele virar uma string.
#define MAX 20
#include "collection.h"
#include <stdio.h>
#include <strings.h>
#include<stdlib.h>
#define TRUE 0
#define FALSE 1
Collection create_queue();
int insere(Collection *fila, char textoAInserir[]);
int retira(Collection *fila, char *textoRemovido);
int inversor(char *textoOriginal, char *textoInvertido);
/*primeira parte fazer vetores
uma fila um conjunto de string (array de char)
retirar sequencialmente da fila
os elemento da fila são retirados e invertidos.
quando */
//----- Esta parte do c?digo n?o pode ser alterada ------
int main(){
char textos[20][20] = { "Abertura", "Continuo", "Contador", "Marcado", "Automovel", "Gentileza", "Verdade", "Fermento", "Teclado", "Barbeiro", "Treinamento", "Dinamismo", "Homenagem", "Levantar", "Integral"};
char textosInvertidos[20][20] = { "arutrebA", "ounitnoC", "rodatnoC", "odacraM", "levomotuA", "azelitneG", "edadreV", "otnemreF", "odalceT", "oriebraB", "otnemanierT", "omsimaniD", "meganemoH", "ratnaveL", "largetnI"};
}
//----------- Final da parte do c?digo que n?o pode ser alterada ---------
Collection create_queue() {
Collection c;
return c;
}
int insere(Collection *fila, char *textoAInserir) {
printf("--> %s\n", textoAInserir);
return TRUE;
}
int retira(Collection *fila, char *textoRemovido) {
strcpy(textoRemovido, "Abertura");
return TRUE;
}
int inversor(char *textoOriginal, char *textoInvertido) {
strcpy(textoInvertido, "arutrebA");
return TRUE;
}