LISTA ENCADEADA ! ! ! Mundo do Blocos ! URGENTE [RESOLVIDO]

1. LISTA ENCADEADA ! ! ! Mundo do Blocos ! URGENTE [RESOLVIDO]

Andreson Barros
dydyXD

(usa XUbuntu)

Enviado em 05/04/2012 - 12:18h

Alguem poderia me ajudar , por que nao ta executando o codigo ! URGENTE !





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

//Definição do TAD
typedef int TChave ;
typedef struct
{
TChave Chave ;
}TItem;
typedef struct Celula* Apontador ;
typedef struct Celula
{
TItem Item;
Apontador pProx ; // Apontador pProx
} TCelula;
typedef struct
{
Apontador pPrimeiro; //Apontador para o primeiro elemento
Apontador pUltimo; //Apontador para o último elemento
}TLista;

//Torna uma lista vazia
void FLVazia(TLista* pLista)
{
// aloca espaço para o célula cabeça
pLista->pPrimeiro = (Apontador)malloc(sizeof(TCelula));
//o último elemento também aponta para a célula cabeça
pLista->pUltimo = pLista->pPrimeiro;
//a célul a cabeça nao aponta para ninguém
pLista->pPrimeiro->pProx = NULL;
}

//verifica se uma lista é vazia
int LEhVazia(TLista* pLista)
{
return (pLista->pPrimeiro == pLista->pUltimo);

}

//insere um item no final da lista
void LInsere(TLista* pLista , TItem* pItem)
{
// aloca-se espaço para o elemento
pLista->pUltimo->pProx = (Apontador)malloc(sizeof(TCelula));
//o ponteiro para o ultimo aponta para a nova célula
pLista->pUltimo = pLista->pUltimo->pProx;
//o item é inserido dentro da célula
pLista->pUltimo->Item = *pItem;
// essa nova célula nao aponta para ninguém
pLista->pUltimo->pProx = NULL;
}
//retira um item da lista
void LRetira(TLista* pLista ,Apontador p ,TItem* pItem)
{
//O item a ser retirado é o seguinte ao apontado por p
Apontador q;
//se a lista for vazia ou o ponteiro nulo nao pode-se retirar
if( LEhVazia(pLista) || p == NULL || p->pProx == NULL)
return;
// q receb e o elemento apontado por p
q = p->pProx;
//retir a-se o item
*pItem = q->Item ;
//atualiza-se os ponteiros
p->pProx = q->pProx ;
//se o elemento retirado for o ultimo pUltimo aponta pra p
if(p->pProx == NULL)
pLista->pUltimo = p;
// libera-se a área de memória
free (q);
}

//retirao primeiro elemento da lista
int LRetiraPrimeiro(TLista *pLista , TItem* pItem)
{
Apontador primeiro;
// se a lista for vazia nao podemos retirar;
if(LEhVazia(pLista))
return 0;
// retira-se o item
*pItem = pLista->pPrimeiro->pProx->Item ;
// guardamos o ponteiro para o primeiro
primeiro = pLista->pPrimeiro;
// atualizamos o primeiro elemento
pLista->pPrimeiro = pLista->pPrimeiro->pProx ;
// libera o espaço de memoria
free(primeiro);
return 1;
}
// imprime uma l i s t a
void LImprime(TLista * pLista)
{
Apontador pAux;
pAux = pLista->pPrimeiro->pProx;
while (pAux != NULL)
{
printf("%d ",pAux->Item.Chave);
pAux = pAux->pProx;
}
}

// d e f i n i ç ã o do TAD
typedef struct
{
TLista * Blocos;
int tamanho;
}TBlocos;

// inicia o mundo dos blocos com os blocos em suas posições iniciais
void InicializarBlocos (TBlocos * pBloco , int n)
{
int i ;
TItem item ;
pBloco->tamanho = n;
// aloca o espaço para os blocos;
pBloco->Blocos = (TLista*) malloc(n* sizeof(TLista));
// preenche o mundo dos blocos
for(i=0;i<n;i++)
{
item.Chave = i;
FLVazia(&pBloco->Blocos&#91;i]); // torna cada lista contendo os blocos vazia
LInsere(&pBloco->Blocos&#91;i], &item);//inicializa o mundo dos blocos
}
}

//Procura os blocos A e B
void ProcuraBlocos (TBlocos * pBloco , int A, int B, int * indiceA , int * indiceB , Apontador* pA, Apontador* pB)
{
int i;
Apontador pAux;
// percorre todos os indices do mundo dos blocos
for (i = 0;i <pBloco->tamanho;i++)
{
pAux = pBloco->Blocos&#91;i].pPrimeiro->pProx ;
//se a lista nao for vazia procuramos nela
if(!(LEhVazia(&pBloco->Blocos&#91;i])))
{
//percorre todos os elementos da lista
while (pAux != NULL)
{
//testa se a chave é igual ao elemento A
if (pAux->Item.Chave == A)
{
//guarda o indice da lista onde A se encontra
*indiceA = i;
//guarda o ponteiro para a celula que contem A
*pA = pAux;
}
//testa se a chave é igual ao elemento A
else if (pAux->Item.Chave == B)
{
// guarda o indice da lista onde B se encontra
*indiceB = i;
// guarda o ponteiro para a celula que contem B
*pB = pAux;
}
// próximo elemento
pAux = pAux->pProx;
}
}
}
}

//Retorna os blocos para suas posições originais
void RetornaParaPosicao (TBlocos * pBloco , int * indiceX , Apontador pX)
{
Apontador pAux;
TItem item;
pAux = pX;
while (pAux->pProx != NULL)
{
// retorna os eventuais blocos em cima do bloco para suas posições originais
LRetira(&pBloco->Blocos [*indiceX ], pX, &item) ;
LInsere(&pBloco->Blocos [item.Chave] ,&item) ;
}
}

//Move o bloco A para cima do bloco B
int MoveAOntoB (TBlocos * pBloco,int A, int B)
{
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
//se A for igual a B não move-se
if (A == B)
return 0;
//procura os blocos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos ( pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao ( pBloco , &indiceA , pA);
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao ( pBloco , &indiceB , pB);
//Move A emcima de B
LRetiraPrimeiro(&pBloco->Blocos [indiceA] , &item);
LInsere(&pBloco->Blocos [indiceB] , &item);
return 1;
}

//Coloca o bloco A no topo do monte onde está o bloco B
int MoveAOverB(TBlocos * pBloco, int A, int B)
{
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
// se A for igual a B não move-se
if (A == B)
return 0;
// procura os blocos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos(pBloco ,A, B, &indiceA , &indiceB, &pA, &pB) ;
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao(pBloco ,&indiceA ,pA) ;
//Move A emcima de B
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item) ;
LInsere(&pBloco->Blocos[indiceB], &item) ;
return 1;
}

//Coloca o bloco A juntamente com todos os blocos que estiverem sobre ele em cima do bloco B
int PileAOntoB (TBlocos * pBloco, int A, int B)
{
int indiceA, indiceB;
Apontador pA, pB;
TItem item;
// se A for igual a B não move-se
if (A == B)
return 0;
//procura os b locos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos (pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estivere na mesma lista retorna 0
if(indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao (pBloco, &indiceB, pB);
//Move A emcima de B
while (!LEhVazia(&pBloco->Blocos[indiceA]))
{
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item) ;
LInsere(&pBloco->Blocos[indiceB], &item) ;
}
return 1;
}

//Coloca o bloco a juntamente com todos os blocos que estiverem sobre ele sobre o monte que contem o bloco b
int PileAOverB (TBlocos * pBloco, int A, int B)
{
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
// se A e B forem iguais retorna 0
if (A == B)
return 0;
//procura os blocos, retorna o indice da lista e um apontador para sua célula
ProcuraBlocos (pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//Move A emcima de B
while (!LEhVazia(&pBloco->Blocos[indiceA]))
{
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item);
LInsere(&pBloco->Blocos[indiceB], &item);
}
return 1;
}

//imprime um conjunto de blocos
void ImprimeBLocos(TBlocos * pBloco)
{
int i;
for (i = 0; i < pBloco->tamanho; i++)
{
printf( "%d: ", i);
LImprime(&pBloco->Blocos&#91;i]);
printf("\n");
}
}

//grava a configuração final em um arquivo
void GravaBLocos (TBlocos * pBloco , char* ArquivoSaida)
{
int i;
Apontador pAux;
//abertura do arquivo
FILE * fp = fopen (ArquivoSaida , "w");
if(!fp)
{
printf( "Erro na abertura do arquivo ");
exit(0);
}

//um loop de 0 at é o tamanho -1
for ( i = 0; i< pBloco->tamanho ; i++)
{
fprintf(fp , "%d: " , i);
pAux = pBloco->Blocos&#91;i].pPrimeiro->pProx;
// percorr e cada lista gravando no arquivo
while (pAux != NULL)
{
fprintf(fp , "%d ", pAux->Item.Chave);
pAux = pAux->pProx;
}
fprintf(fp , "\n");
}
// fecha o arquivo
fclose(fp);
}

int main (int argc , char* argv[])
{
TBlocos Bloco;
char* ArquivoEntrada = argv[1];
char* ArquivoSaida = argv [2];
char Cm1[5] = "";
char Cm2[5] = "";
int A,B,n;
FILE* fp = fopen(ArquivoEntrada , "r");
if(!fp)
{
printf("Erro na abertura do arquivo");
exit(0);
}
// lê o número de blocos
fscanf_s(fp, "%d\n",&n);
//inicializa o mundo dos blocos
InicializarBlocos (&Bloco ,n);
//imprime os blocos para teste
ImprimeBLocos (&Bloco);
printf("\n");
do
{
//lê a linha de comandos
fscanf(fp,"%s %d %s %d\n" ,Cm1, &A, Cm2, &B);
// se o comando for quit sai do loop
if(!(strcmp (Cm1, "quit")))
break ;
//identifica a linha de comando e executa a função
if(!(strcmp (Cm1, "move")))
{
if(!(strcmp(Cm2, "onto")))
MoveAOntoB(&Bloco,A,B);
else
MoveAOverB(&Bloco, A, B) ;
}
else if(!(strcmp (Cm2, "onto")))
PileAOntoB (&Bloco , A, B);
else
PileAOverB(&Bloco ,A,B) ;
}while ((strcmp (Cm1, "quit")));
// imprime os blocos para teste
ImprimeBLocos (&Bloco);
//grava o mundo dos blocos no arquivo especificado
GravaBLocos (&Bloco , ArquivoSaida ) ;
fclose(fp) ;
}



  


2. Re: LISTA ENCADEADA ! ! ! Mundo do Blocos ! URGENTE [RESOLVIDO]

Gordon Freeman
GordonFreeman

(usa Ubuntu)

Enviado em 06/04/2012 - 09:56h

Compile o programa e poste aqui a mensagem de erro com a respectiva linha , que o compilador está retornando,assim fica mais facil ver qual é o problema.Um ótimo IDE para isso é Codeblocks.


3. Re: LISTA ENCADEADA ! ! ! Mundo do Blocos ! URGENTE [RESOLVIDO]

Luis R. C. Silva
luisrcs

(usa Linux Mint)

Enviado em 06/04/2012 - 10:23h


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

//Definição do TAD
typedef int TChave ;
typedef struct{
TChave Chave ;
}TItem;
typedef struct Celula* Apontador ;
typedef struct Celula{
TItem Item;
Apontador pProx ; // Apontador pProx
}TCelula;
typedef struct{
Apontador pPrimeiro; //Apontador para o primeiro elemento
Apontador pUltimo; //Apontador para o último elemento
}TLista;

//Torna uma lista vazia
void FLVazia(TLista* pLista){
// aloca espaço para o célula cabeça
pLista->pPrimeiro = (Apontador)malloc(sizeof(TCelula));
//o último elemento também aponta para a célula cabeça
pLista->pUltimo = pLista->pPrimeiro;
//a célul a cabeça nao aponta para ninguém
pLista->pPrimeiro->pProx = NULL;
}

//verifica se uma lista é vazia
int LEhVazia(TLista* pLista){
return (pLista->pPrimeiro == pLista->pUltimo);
}

//insere um item no final da lista
void LInsere(TLista* pLista , TItem* pItem){
// aloca-se espaço para o elemento
pLista->pUltimo->pProx = (Apontador)malloc(sizeof(TCelula));
//o ponteiro para o ultimo aponta para a nova célula
pLista->pUltimo = pLista->pUltimo->pProx;
//o item é inserido dentro da célula
pLista->pUltimo->Item = *pItem;
// essa nova célula nao aponta para ninguém
pLista->pUltimo->pProx = NULL;
}
//retira um item da lista
void LRetira(TLista* pLista ,Apontador p ,TItem* pItem){
//O item a ser retirado é o seguinte ao apontado por p
Apontador q;
//se a lista for vazia ou o ponteiro nulo nao pode-se retirar
if( LEhVazia(pLista) || p == NULL || p->pProx == NULL)
return;
// q receb e o elemento apontado por p
q = p->pProx;
//retir a-se o item
*pItem = q->Item ;
//atualiza-se os ponteiros
p->pProx = q->pProx ;
//se o elemento retirado for o ultimo pUltimo aponta pra p
if(p->pProx == NULL)
pLista->pUltimo = p;
// libera-se a área de memória
free (q);
}

//retirao primeiro elemento da lista
int LRetiraPrimeiro(TLista *pLista , TItem* pItem){
Apontador primeiro;
// se a lista for vazia nao podemos retirar;
if(LEhVazia(pLista))
return 0;
// retira-se o item
*pItem = pLista->pPrimeiro->pProx->Item ;
// guardamos o ponteiro para o primeiro
primeiro = pLista->pPrimeiro;
// atualizamos o primeiro elemento
pLista->pPrimeiro = pLista->pPrimeiro->pProx ;
// libera o espaço de memoria
free(primeiro);
return 1;
}
// imprime uma l i s t a
void LImprime(TLista * pLista){
Apontador pAux;
pAux = pLista->pPrimeiro->pProx;
while (pAux != NULL){
printf("%d ",pAux->Item.Chave);
pAux = pAux->pProx;
}
}

// d e f i n i ç ã o do TAD
typedef struct{
TLista * Blocos;
int tamanho;
}TBlocos;

// inicia o mundo dos blocos com os blocos em suas posições iniciais
void InicializarBlocos (TBlocos * pBloco , int n){
int i ;
TItem item ;
pBloco->tamanho = n;
// aloca o espaço para os blocos;
pBloco->Blocos = (TLista*) malloc(n* sizeof(TLista));
// preenche o mundo dos blocos
for(i=0;i<n;i++){
item.Chave = i;
FLVazia(&pBloco->Blocos&#91;i]); // torna cada lista contendo os blocos vazia
LInsere(&pBloco->Blocos&#91;i], &item);//inicializa o mundo dos blocos
}
}

//Procura os blocos A e B
void ProcuraBlocos (TBlocos * pBloco , int A, int B, int * indiceA , int * indiceB , Apontador* pA, Apontador* pB){
int i;
Apontador pAux;
// percorre todos os indices do mundo dos blocos
for (i = 0;i <pBloco->tamanho;i++){
pAux = pBloco->Blocos&#91;i].pPrimeiro->pProx ;
//se a lista nao for vazia procuramos nela
if(!(LEhVazia(&pBloco->Blocos&#91;i]))){
//percorre todos os elementos da lista
while (pAux != NULL){
//testa se a chave é igual ao elemento A
if (pAux->Item.Chave == A){
//guarda o indice da lista onde A se encontra
*indiceA = i;
//guarda o ponteiro para a celula que contem A
*pA = pAux;
}
//testa se a chave é igual ao elemento A
else if (pAux->Item.Chave == B){
// guarda o indice da lista onde B se encontra
*indiceB = i;
// guarda o ponteiro para a celula que contem B
*pB = pAux;
}
// próximo elemento
pAux = pAux->pProx;
}
}
}
}

//Retorna os blocos para suas posições originais
void RetornaParaPosicao (TBlocos * pBloco , int * indiceX , Apontador pX){
Apontador pAux;
TItem item;
pAux = pX;
while (pAux->pProx != NULL){
// retorna os eventuais blocos em cima do bloco para suas posições originais
LRetira(&pBloco->Blocos [*indiceX ], pX, &item) ;
LInsere(&pBloco->Blocos [item.Chave] ,&item) ;
}
}

//Move o bloco A para cima do bloco B
int MoveAOntoB (TBlocos * pBloco,int A, int B){
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
//se A for igual a B não move-se
if (A == B)
return 0;
//procura os blocos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos ( pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao ( pBloco , &indiceA , pA);
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao ( pBloco , &indiceB , pB);
//Move A emcima de B
LRetiraPrimeiro(&pBloco->Blocos [indiceA] , &item);
LInsere(&pBloco->Blocos [indiceB] , &item);
return 1;
}

//Coloca o bloco A no topo do monte onde está o bloco B
int MoveAOverB(TBlocos * pBloco, int A, int B){
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
// se A for igual a B não move-se
if (A == B)
return 0;
// procura os blocos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos(pBloco ,A, B, &indiceA , &indiceB, &pA, &pB) ;
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao(pBloco ,&indiceA ,pA) ;
//Move A emcima de B
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item) ;
LInsere(&pBloco->Blocos[indiceB], &item) ;
return 1;
}

//Coloca o bloco A juntamente com todos os blocos que estiverem sobre ele em cima do bloco B
int PileAOntoB (TBlocos * pBloco, int A, int B){
int indiceA, indiceB;
Apontador pA, pB;
TItem item;
// se A for igual a B não move-se
if (A == B)
return 0;
//procura os b locos , retorna o indice da lista e um apontador para sua célula
ProcuraBlocos (pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estivere na mesma lista retorna 0
if(indiceA == indiceB)
return 0;
//retorna os blocos sobre A para suas posições originais
RetornaParaPosicao (pBloco, &indiceB, pB);
//Move A emcima de B
while (!LEhVazia(&pBloco->Blocos[indiceA])){
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item) ;
LInsere(&pBloco->Blocos[indiceB], &item) ;
}
return 1;
}

//Coloca o bloco a juntamente com todos os blocos que estiverem sobre ele sobre o monte que contem o bloco b
int PileAOverB (TBlocos * pBloco, int A, int B){
int indiceA , indiceB;
Apontador pA, pB;
TItem item;
// se A e B forem iguais retorna 0
if (A == B)
return 0;
//procura os blocos, retorna o indice da lista e um apontador para sua célula
ProcuraBlocos (pBloco, A, B, &indiceA, &indiceB, &pA, &pB);
// se A e B estiverem na mesma lista retorna 0
if (indiceA == indiceB)
return 0;
//Move A emcima de B
while (!LEhVazia(&pBloco->Blocos[indiceA])){
LRetiraPrimeiro(&pBloco->Blocos[indiceA], &item);
LInsere(&pBloco->Blocos[indiceB], &item);
}
return 1;
}

//imprime um conjunto de blocos
void ImprimeBLocos(TBlocos * pBloco){
int i;
for (i = 0; i < pBloco->tamanho; i++){
printf( "%d: ", i);
LImprime(&pBloco->Blocos&#91;i]);
printf("\n");
}
}

//grava a configuração final em um arquivo
void GravaBLocos (TBlocos * pBloco , char* ArquivoSaida){
int i;
Apontador pAux;
//abertura do arquivo
FILE * fp = fopen (ArquivoSaida , "w");
if(!fp){
printf( "Erro na abertura do arquivo ");
exit(0);
}

//um loop de 0 at é o tamanho -1
for ( i = 0; i< pBloco->tamanho ; i++){
fprintf(fp , "%d: " , i);
pAux = pBloco->Blocos&#91;i].pPrimeiro->pProx;
// percorr e cada lista gravando no arquivo
while (pAux != NULL){
fprintf(fp , "%d ", pAux->Item.Chave);
pAux = pAux->pProx;
}
fprintf(fp , "\n");
}
// fecha o arquivo
fclose(fp);
}

int main (int argc , char* argv[]){
TBlocos Bloco;
char* ArquivoEntrada = argv[1];
char* ArquivoSaida = argv [2];
char Cm1[5] = "";
char Cm2[5] = "";
int A,B,n;
FILE* fp = fopen(ArquivoEntrada , "r");
if(!fp){
printf("Erro na abertura do arquivo");
exit(0);
}
// lê o número de blocos
fscanf_s(fp, "%d\n",&n);
//inicializa o mundo dos blocos
InicializarBlocos (&Bloco ,n);
//imprime os blocos para teste
ImprimeBLocos (&Bloco);
printf("\n");
do{
//lê a linha de comandos
fscanf(fp,"%s %d %s %d\n" ,Cm1, &A, Cm2, &B);
// se o comando for quit sai do loop
if(!(strcmp (Cm1, "quit")))
break ;
//identifica a linha de comando e executa a função
if(!(strcmp (Cm1, "move"))){
if(!(strcmp(Cm2, "onto")))
MoveAOntoB(&Bloco,A,B);
else
MoveAOverB(&Bloco, A, B) ;
}
else if(!(strcmp (Cm2, "onto")))
PileAOntoB (&Bloco , A, B);
else
PileAOverB(&Bloco ,A,B) ;
}
while ((strcmp (Cm1, "quit")));
// imprime os blocos para teste
ImprimeBLocos (&Bloco);
//grava o mundo dos blocos no arquivo especificado
GravaBLocos (&Bloco , ArquivoSaida ) ;
fclose(fp) ;
}



Pelo que eu estou observando por alto, tem muito erro de sintaxe. Revise o código.


4. Re: LISTA ENCADEADA ! ! ! Mundo do Blocos ! URGENTE [RESOLVIDO]

André
andrezc

(usa Debian)

Enviado em 06/04/2012 - 10:25h

"Não está executando" é muito vago. O código compila? Caso não compile, há alguma mensagem de erro? Você sabe o que ele faz?






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts