Problema Adicionar no sitio certo

[HIT_Braga]

Boas pessoal.

Mais uma vez recorro a vocês para me ajudarem. Estou a dar em maluco....

typedef struct grafo{
char tipo[30];
char id[20];
struct grafo *proximo;
struct no *Adjacentes;
};
typedef struct no {
   char tipo[30];
   char id[20];
   int peso;
   struct no *proximo;
   } no;
no * procurar(char *tipo) {

  grafo *ponteiro;

  ponteiro = first;

  while ((ponteiro)&&(strcmp(tipo, ponteiro->tipo)!=0)) {

		ponteiro = ponteiro->proximo;

  }

  return ponteiro->Adjacentes ;
}
void inserirAdj(grafo *g,char *tipo) {
alocar = (struct no *) malloc(sizeof(struct no));
no *aux=procurar("c");
aux=alocar;
if (!alocar) {
   printf("Falta de memória");
   exit(0);
}
strcpy(alocar->tipo, tipo);

 if (!primeiro) {
	 primeiro = alocar;
	 ultimo = alocar;	
 }
 else
 {
	 ultimo->proximo = alocar;						
	 ultimo = alocar;					
 }
 ultimo->proximo = NULL;
}

O que eu pretendo é inserir o dado na lista Adjacentes. Não sei o que está mal, está a adicionar sempre no primeiro item da lista ligada Grafo, e o que eu pretendo é procurar onde está a letra correspondente, e ir à lista ligada dos adjacentes e colocar lá.

A lógica que eu penso é: procurar na lista ligada Grafo pelo item e retornar o apontador para Adjacentes, e achava que estava a fazer isso, mas pelos vistos não.

Sds,

HIT

Edited May 31, 2012 at 03:20 PM by Baderous
geshi

[HappyHippyHippo]

eu nem sei como compila !!!

       if (!primeiro) {

de onde vem esta variável primeiro ? para não falar na ultimo ...

e uma questão ... o que achas que a função procurar deveria retorna caso não exista o nó com o tipo pedido ??

[HIT_Braga]

// listlinked.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <stdio.h>
#include <string.h>
#include <malloc.h>
#include <stdlib.h>

/*Declaração do tipo nó para a lista, composto de
ponteiro para o próximo nó e de um campo para tipo
que no caso é o campo char tipo[30];
*/
typedef struct grafo{
char tipo[30];
char id[20];
struct grafo *proximo;
struct no *Adjacentes;
};
typedef struct no {
   char tipo[30];
   char id[20];
   int peso;
   struct no *proximo;
   } no;

no *primeiro = NULL; //Ponteiro para o primeiro elemento da lista
no *ultimo = NULL; //Ponteiro para o último elemento da lista
no *alocar; //Ponteiro para fazer alocação
grafo *first=NULL;
grafo *last=NULL;
grafo *gravar;


no * procurar(char *tipo) {

  grafo *ponteiro;

  ponteiro = first;

  while ((ponteiro)&&(strcmp(tipo, ponteiro->tipo)!=0)) {

		ponteiro = ponteiro->proximo;

  }

  return ponteiro->Adjacentes ; //Retorna o ponteiro para a região da memória
				   //que está apontando (caso encontre)
				   //Retorna o ponteiro NULL (caso em que não encontra)
}
void inserirGrafo(char *tipo) {

gravar = (struct grafo *) malloc(sizeof(struct grafo)); //Faz alocação na memória

if (!gravar) { //Se não for possível a alocação, sai do programa
   printf("Falta de memória");
   exit(0);
}

strcpy(gravar->tipo, tipo); //Copia o tipo para o novo nó alocado

 if (!first) { //Se não houver elemento ainda na lista, insere
				  //insere na primeira posição apontando o ponteiro
				  //"primeiro" e último
	 first = gravar;
	 last = gravar;

 }

 else //se não...

 {
	 last->proximo = gravar; //Aponta o "próximo" do último elemento
							   //para o novo nó alocado
	 last = gravar;		  //Aponta o marcador de "ultimo" para o
							   //novo nó alocado

 }
 last->proximo = NULL; //Aponta o "próximo" do último nó para o ponteiro
						 //nulo, para verificação de fim de lista
}
void inserirAdj(grafo *g,char *tipo) {
alocar = (struct no *) malloc(sizeof(struct no));
no *aux=procurar("c");
aux=alocar;
if (!alocar) {
   printf("Falta de memória");
   exit(0);
}
strcpy(alocar->tipo, tipo);

 if (!primeiro) {
	 primeiro = alocar;
	 ultimo = alocar;	
 }
 else
 {
	 ultimo->proximo = alocar;						
	 ultimo = alocar;					
 }
 ultimo->proximo = NULL;
}
void printGrafo()
{
grafo *ponteiro=first;
no *ptr=primeiro;
while (ponteiro) {
	   printf("\n%s", ponteiro->tipo);
	   while(ptr){
		   printf(" --- %s", ptr->tipo);
		   ptr=ptr->proximo;
	   }
	   ponteiro = ponteiro->proximo;
	  }

}
void imprimir() {
 no *ponteiro = primeiro;
 no *aux =gravar->Adjacentes;
 while (ponteiro) {
	   printf("\n%s", ponteiro->tipo);
	   while (aux){
		   printf("\n%s", aux->tipo);
		   aux=aux->proximo;
	   }
	   ponteiro = ponteiro->proximo;
	  }
 }
int main() {
  char tipo[30];
printf("\nInserir: ");
gets(tipo);
inserirGrafo(tipo);
printf("\nInserir: ");
gets(tipo);
inserirGrafo(tipo);
printf("\nInserir: ");
gets(tipo);
inserirGrafo(tipo);
printf("\nInserir: ");
gets(tipo);
inserirGrafo(tipo);
printf("\nInserirADJ: ");
gets(tipo);
inserirAdj(gravar,tipo);
printf("\nInserirADJ: ");
gets(tipo);
inserirAdj(gravar,tipo);
printf("\nInserirADJ: ");
gets(tipo);
inserirAdj(gravar,tipo);
printf("\nInserirADJ: ");
gets(tipo);
inserirAdj(gravar,tipo);
//inserirGrafo(tipo);
//imprimir();
printGrafo();  
getchar();
}

Aqui está o código completo.

O nó irá existir sempre, pois é adicionado antes. Também pode retornar um apontador do tipo NULL e depois implemento

if (procurar("a")==NULL) exit(0);
else{
//codigo
}

Mas em principio existirá sempre esse elemento na lista.

Sei que o código não está o melhor mas tenho de fazer este trabalho, e estou um pouco à rasca.

Sds,

Edited May 31, 2012 at 03:21 PM by Baderous
geshi

[Flinger]

ponteiro = first;

Mais este first, também não o vejo em lado nenhum, e parece-me estranhamente parecido com o "primeiro" 😄

A menos que esteja a trabalhar com globais (pessoalmente considero meio caminho andado para dar problemas), estas variáveis aparecem vindas do nada. Se estiveres a usar globais vê lá os nomes que estás a dar, e se não estás a inserir num lado e a procurar noutro.

[HappyHippyHippo]

se tens variáveis globais assim espalhadas o meu conselho é só um (e como o teu código tem um número misero de linha de código) :

apaga tudo e começa tudo do início, mas desta vez com estruturas decentes sem uma única variável global !!!!

Nota : sabes que estás a usar os mesmos ponteiros (primeiro e ultimo) para referenciar elementos de múltiplas listas ... o que é impossível ...

[Flinger]

Segue o conselho do Hyppo e tira daí as globais...

De qualquer forma o problema está aqui:

no *aux=procurar("c");
aux=alocar;

1 - Fazes a procura pelo tipo "c" e não pelo parâmetro tipo que passas à função.

2 - descartas o apontador para essa lista de adjacências, já que escreves por cima o apontador para a nova adjacência, e ainda por cima não usas essa variável no resto da função.

3- a minha única dúvida é como o teu programa consegue sequer ligar estas adjacências a algum nó... provavelmente algum efeito das variáveis globais que estás a usar, caso contrário já terias dado por ela do erro à muito tempo.

EDIT: ...

Pois. Tu assim não tens um grafo, tens basicamente 2 listas separadas. Uma com os "Grafos" (apontada por first e last) e outra com os "nós", apontada por primeiro e ultimo. Mas os "nós" simplesmente não estão ligados aos "grafos" de nenhuma forma.

Mais coisas: se a procurar não encontrar o nodo que queres vai dar segmentation fault.

no * procurar(char *tipo) {

	  grafo *ponteiro;

	  ponteiro = first;

	  while ((ponteiro)&&(strcmp(tipo, ponteiro->tipo)!=0)) {

				ponteiro = ponteiro->proximo;

	  }

	  return ponteiro->Adjacentes ; //Retorna o ponteiro para a região da memória
									   //que está apontando (caso encontre)
									   //Retorna o ponteiro NULL (caso em que não encontra)

Quando saíres do while por na haver mais nodos, ponteiro é NULL. Return NULL->proximo vai dar estouro.