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

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) ;
}

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.

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.

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?