C Fazer uma lista apontar para outra

[Igor Vargas]

Olá estou com duvida de como faço para minha lista LESTRAS apontar para CONTATOS. Toda vez que eu digito um novo nome preciso guardar a inicial do nome e apontar ela para os nomes que contem aquela inicial, mas estou com problemas para implementar.

 

 

 

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM 50

  
  #define MAX 500
typedef struct CONTATO{
	char *nome;
	char *sobrenome;
	int numeroT;
	char *email;
	struct CONTATO *prox;
	struct CONTATO *inicial;
	
}contato;

typedef struct LETRAS{
	
	char inicial;
	struct LETRAS *prox;
}letras;



contato *inserir(char *nome,char *sobrenome,char *email, int numero, contato *c){
	contato *novo;
	novo = (contato*)malloc(sizeof(contato));
	novo->nome =(char *)malloc(strlen(nome)+1);
	strcpy(novo->nome,nome);
	
	novo->sobrenome=(char *)malloc(strlen(sobrenome)+1);
	strcpy(novo->sobrenome,sobrenome);
	
	novo->email=(char *)malloc(strlen(email)+1);
	strcpy(novo->email,email);
	
	novo->numeroT=numero;
	novo->prox = c;
	return novo;
}

letras *insereChar(letras *l, char nome){
	letras *novo;
	novo = (letras*)malloc(sizeof(letras));
	novo->inicial = nome;
	novo->prox = l;
	return novo;
}

void ordenar(contato *l) {
 
    if(l == NULL || l->prox == NULL) return; //se for nulo(vazio), ou apenas 1 elemento
    contato *aux = l;
    contato *t;
    char s[MAX]; //precisa de espacao suficiente para armazenar o nome
 
    while(aux != NULL) {
      t = aux->prox;
      while(t != NULL) {
        if(strcmp(aux->nome, t->nome) > 0) { //se vir depois
            strcpy(s, aux->nome);
            strcpy(aux->nome, t->nome);
            strcpy(t->nome, s);
        }
        t = t->prox;
      }
      aux = aux->prox;
    }
}

void imprime(contato *c, letras *l){
	contato *p=c;
	letras *t=l;
	while(p!=NULL && t!=NULL){
		//printf("\n");
		printf("%c-> %s %s\n",t->inicial,p->nome,p->sobrenome);
	
	t =t->prox;	
	p=p->prox;	
	}
}

main(){
contato *l;
letras *c;
l = NULL;
c = NULL;
char nome[TAM];
char sobrenome[TAM];
char email[TAM];
int numero;
		printf("_______________________\n");
		printf("Bem-Vindo a Sua Agenda\n");
		printf("_______________________\n");
		//printf("\n");
int escolha;

do{
printf("\n");
printf("1: Adicionar contato\n");
printf("2: Remover Contato\n");
printf("3: Exibir Contatos\n");
printf("4: Favoritos\n");
printf("5: Sair\n");

printf("_______________________\n");
printf("Escolha a Opcao Desejada: ");
scanf("%d",&escolha);


switch(escolha){
	
	case 1:
	printf("_______________________\n");
	printf("voce Selecionou Adicionar Contato\n");
	printf("_______________________\n");	
	printf("Nome do Contato: ");	
	fflush(stdin);
	gets(nome);
	char passa = nome[0];
	c = insereChar(c,passa);
	printf("Sobrenome do Contato: ");
	gets(sobrenome);
	fflush(stdin);
	printf("email do contato: ");
	gets(email);
	printf("Numero de Contato: ");
	scanf("%d",&numero);
	l =inserir(nome,sobrenome,email,numero,l);
	ordenar(l);	
	break;
	
	case 2:
	
	break;	
	
	case 3:
	imprime(l,c);
	break;
	
	case 4:
		
	break;
	
	default:
		printf("Fim do Programa");
	break;
	
	
	
	
}
	}while(escolha != 5);	
	
	
	
}

 

[Ansi C]

Olá!

 Fica confuso quando os identificadores (nomes dos objetos) contradizem formato do objeto que estão identificando.

 

E essa estrutura

21 horas atrás, Igor Vargas disse:

typedef struct LETRAS {
  
  char inicial; // uma variável char é espaço suficiente para uma "letra", e nada mais !!!
  struct LETRAS *prox;
} letras;

 

 

Não conecta os nomes das pessoas, pelo motivo de só ter espaço para UMA letra e nada mais. Sua melhor alternativa é criar um vetor. E orientar a lista conforme o primeiro nome e salvar em um vetor bem simples: caso por exemplo seja o meu nome AnsiC, basta me adicionar na posição 'A' do vetor de contatos.

 

/* declarando o índice alfabético */
contato *indices[255]= {0};

/* para acessar a lista dos contatos que começam com 'A' */
contato *que_comecam_com_A= indices['A'];

/* pronto agora far-se-á  as modificações que deseja na lista A */
/* por exemplo; adicionar um contado na última posição do índice A */
contato *que_comeca_com_a= indices['A'];

/* testa primeiro se o índice é virgem, se é então adicione o seu primeiro item */
if(que_comeca_com_a == NULL){indices['A']= novo_contato;}

/* caso não seja */
else{ /* adicionará o novo contato no fim da lista de contatos A */

	while(que_comeca_com_a->proximo != NULL)que_comeca_com_a= comeca_com_a->proximo;
	que_comeca_com_a->proximo= novo_contato;}

_____________________________________

Tem alguma dúvida de que isso não dá certo?

Pode deixar perguntas

O.k!

 

UPDATE:

Uma última coisa: De modo geral nós não colocamos os ponteiros *anterio, *proximo dentro da estrutura com os dados da estrutura, e sim em outra estrutura comumente chamada de no (do inglês node) com 3 ponteiros.

typedef struct Node {
  
  tipo_dado *dado;
  
  struct Node *proximo;
  struct Node *anterio;
} node_t;

 

[Igor Vargas]

@AnsiC eu tenho que fazer algo parecido com a ilustração abaixo.  Não entendi muito bem essa parte de apontar para outra lista. Porque as letras estão em outra lista, o que eu pensei em fazer é. Por exemplo. eu digito Igor, pego a inicial "i" e aponto ela pra lista que vai estar com meu nome, agora eu adiciono outra pessoa digamos AnsiC faço a mesma coisa só que o ultimo nome teria que apontar pra proxima letra como se fosse uma lista, foi assim que eu entendi. Mas não estou conseguindo emplementar.

adicionado 9 minutos depois

@AnsiC Eu dei uma atualizada no código.

 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "agenda.h"
#define TAM 50


main(){
contato *c;
letras *l;
c = NULL;
l = NULL;
char nome[TAM];
char sobrenome[TAM];
char email[TAM];
int numero;
		printf("_______________________\n");
		printf("Bem-Vindo a Sua Agenda\n");
		printf("_______________________\n");
		//printf("\n");
int escolha;

do{
printf("\n");
printf("1: Adicionar contato\n");
printf("2: Remover Contato\n");
printf("3: Exibir Contatos\n");
printf("4: Favoritos\n");
printf("5: Sair\n");

printf("_______________________\n");
printf("Escolha a Opcao Desejada: ");
scanf("%d",&escolha);


switch(escolha){
	
	case 1:
	printf("_______________________\n");
	printf("voce Selecionou Adicionar Contato\n");
	printf("_______________________\n");	
	printf("Nome do Contato: ");	
	fflush(stdin);
	gets(nome);
	printf("Sobrenome do Contato: ");
	gets(sobrenome);
	fflush(stdin);
	printf("email do contato: ");
	gets(email);
	printf("Numero de Contato: ");
	scanf("%d",&numero);
	c =inserir(nome,sobrenome,email,numero,c);
	l = insereChar(c,l);
	ordenar(c);	
	break;
														//menu do programa
	case 2:
	printf("_______________________\n");
	printf("voce Selecionou Remover Contato\n");
	printf("_______________________\n");
	printf("Digite o nome do contato: ");
	char nomec[TAM],sobrenomec[TAM];
	fflush(stdin);
	gets(nomec);
	printf("Digite o Sobrenome: ");
	gets(sobrenomec);
	l =retiranome(c,nomec);
	l =retirasobrenome(c,sobrenomec);
	printf("Contato removido com sucesso!\n");
	break;	
	
	case 3:
	imprime(c,l);
	break;
	
	case 4:
		
	break;
	
	default:
		printf("Fim do Programa");
	break;
	
	
	
	
}
	}while(escolha != 5);	
	
	
	
}

 

As funções estão nesse biblioteca

 

#define TAM 50
#define MAX 500
typedef struct CONTATO{
char *nome;
char *sobrenome;
int numeroT;
char *email;
struct CONTATO *prox;
}contato;


typedef struct LETRAS{
char inicial;
struct LETRAS *prox;
}letras;


contato *inserir(char *nome,char *sobrenome,char *email, int numero, contato *c){
contato *novo;
novo = (contato*)malloc(sizeof(contato));
novo->nome =(char *)malloc(strlen(nome)+1);
strcpy(novo->nome,nome);
novo->sobrenome=(char *)malloc(strlen(sobrenome)+1);
strcpy(novo->sobrenome,sobrenome);
novo->email=(char *)malloc(strlen(email)+1);
strcpy(novo->email,email);
//inserção de contatos
novo->numeroT=numero;
novo->prox = c;
return novo;
}


letras *insereChar(contato *c,letras *l){
letras *novo;
contato *novoc = c;
char passa[TAM];
if(c == NULL){
return 0;
}else{
novo = (letras*)malloc(sizeof(letras));
passa[TAM]= novoc->nome;
strcpy(passa,c->nome);
char i = passa[0];
novo->inicial = i;
novo->prox = l;
//inserção de iniciais
}
return novo;
}


void ordenar(contato *c) {
if(c == NULL || c->prox == NULL) return; //se for nulo(vazio), ou apenas 1 elemento
contato *aux = c;
contato *t;
char s[MAX]; //precisa de espacao suficiente para armazenar o nome
while(aux != NULL) {
t = aux->prox;
while(t != NULL) {
if(strcmp(aux->nome, t->nome) > 0) { //se vir depois
strcpy(s, aux->nome);
strcpy(aux->nome, t->nome);
strcpy(t->nome, s);
}
t = t->prox;
}
aux = aux->prox;
}
}


void imprime(contato *c, letras *l){
contato *p=c;
letras *t=l;
while(p!=NULL && t!=NULL){
//printf("\n");
printf("%c-> %s %s\n",t->inicial,p->nome,p->sobrenome);
t =t->prox;	
p=p->prox;	
}
}


contato *retiranome(contato *c, char *nome){
contato *ant = NULL;
contato *p = c;
while (p!=NULL && strcmp(p->nome,nome)!=0){
ant = p;
p = p->prox;
}
if(p == NULL){
return c;						//retira o nome
}
if(ant == NULL){
c = p->prox;
}else{
ant->prox = p->prox;
}
free(p);
return c;
}


contato *retirasobrenome(contato *c, char *sobrenome){
contato *ant = NULL;
contato *p = c;
while (p!=NULL && strcmp(p->sobrenome,sobrenome)!=0){
ant = p;
p = p->prox;				//retira o sobrenome
}
if(p == NULL){
return c;
}
if(ant == NULL){
c = p->prox;
}else{
ant->prox = p->prox;
}
free(p);
return c;
}

 

[Ansi C]

@Igor Vargas Entendi!

Então é da maneira abaixo que estrutura letra tem que ser aproximadamente.

Digamos que você entre com nome: Igor ... Daí existe um lista chamadas iniciais, vamos ver isso em código logo baixo.

typedef struct Letra {
  
  char letra;
  
  struct Contato *lista_de_contatos;
  struct Letra *proximas;
} letra_t;
  

 

Primeiro você declara o ponteiros da lista de iniciais.

/* Lista com as iniciais e todos os contados organizados alfabeticamente */
letra_t *iniciais= NULL; /* lista vazia declarada */

 

Agora digamos que você entrou com um contato.

/* Antes, verifica-se a lista está virgem, se sim então adiciona-se a primeira letra
/* conforme a primeira entrada, pois foi essa quem deu inicio as iniciais */
if(iniciais == NULL){
  
  /* reservando dinamicamente memória para primeira letra das iniciais */
  iniciais= malloc(sizeof(letra_t));
  
  /* associando os primeiros dados da lista */
  iniciais->letra= contato_inicial_do_nome;
  iniciais->lista_de_contatos= contato;
  iniciais->proximas= NULL;}

/* Caso a lista de iniciais já tenha contatos nela
/* pode, se quiser, proceder desta forma */
else {
  
  /* tipo temporário para não modificar a estrutura na memória, por enquanto */
  letra_t *buscar= iniciais;
  while(buscar != NULL){
    
    /* testar para letra na variável contato_inicial_do_nome
    /* se encontrada adiciona no começa da lista */
    if(buscar->letra == contato_inicial_do_nome){
      
      /* primeiro adicionamos a cabeça da lista no ponteiro do novo contato */
      contato->proximo= buscar->lista_de_contatos;
      
      /* depois tornamos o novo contato a cabeça da lista e finaliza o loop */
      buscar->lista_de_contatos= contato;
      break;}
    
    /* caso o teste de negativo para o if, incrementamos a lista */
    else{ buscar= buscar->proximas; }}
    
    /* Caso a letra da inicial foi encontrada então buscar vai ser diferente de null
    /* se não então deve-se mais essa inicial; pois ela é nova no sistema */
    if(buscar == NULL){
      
      letra_t *tmp_iniciais= malloc(sizeof(letra_t));
      
      /* associando os primeiros dados da lista */
      tmp_iniciais->letra= contato_inicial_do_nome;
      tmp_iniciais->lista_de_contatos= contato;
      
      /* primeiro adicionamos a cabeça das iniciais no ponteiro do nova inicial */
      tmp_iniciais->proximas= iniciais;
      
      /* agora tornamos a nova inicial a cabeça da lista de iniciais */
      iniciais= tmp_iniciais;}
  

________________________________________________

Você entendeu isso como correto? Qualquer sugestão fale. 

O.k!

[Igor Vargas]

@AnsiC essa variavel, eu pego como?.

1 hora atrás, AnsiC disse:

contato_inicial_do_nome

Desse jeito?

2 horas atrás, Igor Vargas disse:

passa[TAM]= novoc->nome;

strcpy(passa,c->nome);

char i = passa[0];

novo->inicial = i;

[Ansi C]

Então tem-se a seguinte estrutura contato né?

typedef struct CONTATO{
  
	char *nome;
	char *sobrenome;
	int numeroT;
	char *email;
  
	struct CONTATO *prox;
	struct CONTATO *inicial;
	
}contato;

 

Estanciado um variável contato, pode-se acessar a inicial desta maneira:

/* instanciado um novo contato */
contato *novo_contato= malloc(sizeof(contato));

/* acessamos o inicial do nome desta forma */
char inicial_do_novo_contato= novo_contato->nome[0];

Você entende isso?

[Igor Vargas]

@AnsiC Eu acho que entendi. Vai ficar algo assim?

 

letra_t *insereChar(contato *c,letra_t *iniciais){          //aqui eu coloco os contatos na lista da letra
contato *novo_contato= malloc(sizeof(contato));
char inicial_do_novo_contato= novo_contato->nome[0];
  
if(iniciais == NULL){
iniciais= malloc(sizeof(letra_t));
iniciais->letra = c->nome;
iniciais->lista_de_contatos=c;
iniciais->prox = NULL;	
}else{
letra_t *buscar=iniciais;
while(buscar !=NULL){
if(buscar->letra == inicial_do_novo_contato){
c->prox = buscar->lista_de_contatos;
buscar->lista_de_contatos = c;
break;
}else{
buscar=buscar->prox;
}
}
if(buscar == NULL){
letra_t *tmp_iniciais= malloc(sizeof(letra_t));
tmp_iniciais->letra= c->nome;
tmp_iniciais->lista_de_contatos= c;
tmp_iniciais->prox= iniciais;
iniciais= tmp_iniciais;
}
}	
return iniciais;	
}

A minha função de impressão, não ta imprimindo a letra.

void imprime(contato *c, letra_t *l){
contato *p=c;
letra_t *t=l;
while(p!=NULL && t!=NULL){
//printf("\n");
printf("%c ->%s %s\n",t->letra,p->nome,p->sobrenome);
t =t->prox;	
p=p->prox;	
}
}

 

[Ansi C]

@Igor Vargas És um exemplo "do sistema" em código funcionando.

 

Contato

typedef struct Contato {
  
  int numeroT;
  char *nome;
  char *sobrenome;
  char *email;

  struct Contato *prox;
  struct Contato *inicial;}
  contato_t;

 

Letra

typedef struct Letra {
  
  char letra;
  
  struct Contato *lista_de_contatos;
  struct Letra *prox;}
  letra_t;

 

função insere_char

letra_t *insere_char(contato_t *c, letra_t *iniciais){
  char inicial_do_novo_contato= c->nome[0];
  
  if(iniciais == NULL){
    iniciais= malloc(sizeof(letra_t));

    iniciais->letra= inicial_do_novo_contato;
    iniciais->lista_de_contatos= c;
    iniciais->prox = NULL;}
  
  else {
    letra_t *buscar= iniciais;

    while(buscar != NULL){
      if(buscar->letra == inicial_do_novo_contato){
        c->prox= buscar->lista_de_contatos;
        buscar->lista_de_contatos= c;
        break;}
      
      else {buscar= buscar->prox;}}
    
    if(buscar == NULL){
      letra_t *tmp_iniciais= malloc(sizeof(letra_t));

      tmp_iniciais->letra= inicial_do_novo_contato;
      tmp_iniciais->lista_de_contatos= c;
      tmp_iniciais->prox= iniciais;
      iniciais= tmp_iniciais;}}
  
  return iniciais;}

 

função imprime

void imprime(letra_t *iniciais){
  puts("**** Lista de contatos por iniciais");

  contato_t *contatos;
  
  while(iniciais != NULL){
    printf("  %c :  ", iniciais->letra);
    contatos= iniciais->lista_de_contatos;
    
    while(contatos != NULL){
      printf("%s, ", contatos->nome);
      contatos= contatos->prox;}

    puts("\b\b.");
    iniciais= iniciais->prox;}

  return;}

 

exemplo

int main(void){

  /* lista de contatos de exemplo */
  letra_t *iniciais= NULL;

  /* contatos de exemplo */
  contato_t cont1= {1, "AnsiC ISO 1", "Membro", "@email.com", NULL, NULL};
  contato_t cont2= {2, "AnsiC ISO 9", "Membro", "@email.com", NULL, NULL};
  contato_t cont3= {3, "Igor Vargas", "Membro", "@email.com", NULL, NULL};

  /* usando a rotina que cria a lista alfabética */
  iniciais= insere_char(&cont1, iniciais);
  iniciais= insere_char(&cont2, iniciais);
  iniciais= insere_char(&cont3, iniciais);

  /* exibir a lista de exemplo */
  imprime(iniciais);

  return 0;}

________________________________________________________________

Importante: O campo prox dos contatos está servindo à lista de ordem alfabética.

O.k!?

[Igor Vargas]

@AnsiC valeu pela ajuda, não consegui entender direito listas ainda, mas to me esforçando haha. No caso da ordenação eu terei que fazer pela letra, certo?

[Ansi C]

16 minutos atrás, Igor Vargas disse:

ordenação eu terei que fazer pela letra, certo?

Certo.

[Igor Vargas]

@AnsiC Fiz a ordenação dessa maneira, mas acho que esta faltado algo. Porque ele mostra duas vezes o nome da pessoa. Digamos na lista que tem os nomes com  "i" e depois mostra na lista certa.

 

void ordena_alfa(letra_t * l) {

  if (l == NULL || l - > prox == NULL) return; //se for nulo(vazio), ou apenas 1 elemento
  letra_t * aux = l;
  letra_t * t;
  char s;

  while (aux != NULL) {
    t = aux - > prox;
    while (t != NULL) {
      if (aux - > letra > t - > letra) { //se vir depois
        s = aux - > letra;
        aux - > letra = t - > letra;
        t - > letra = s;
      }
      t = t - > prox;
    }
    aux = aux - > prox;
  }
}

 

[Ansi C]

Quase! Porque não é só para trocar a letra, é para trocara a letra e também a lista de contatos.

adicionado 1 minuto depois

Pense... faz alguma sentido troca as letras e deixar os contatos ???

você entendeu isso?

O.k!

[Igor Vargas]

eu tenho que apontar a letra pro nome que tem o mesmo inicio só que em ordem?.

Tem algum material que  tu possa me recomendar pra  dar uma lida ?

 

@AnsiC

[Ansi C]

Todos de Paul J. Deitel & Harvey M. Deitel,

 

também conhecidos como: Deitel - Como programar em C. Você encontra em PDF para download na internet.

Porém não lembro de nenhum livro com o seu caso específico. Se procurar ordenação de lista em ordem alfabética talvez tenha mais sorte.

[Igor Vargas]

@AnsiC Estou com uma certa dúvida numa parte desse trabalho que estou fazendo. O trabalho pede pra mim criar uma lista favoritos, receber ela da lista contatos, caso a pessoa queira adicionar um contato aos favoritos, se a pessoa excluir um contato da lista de favoritos ele ser excluido da lista normal. O problema é que o professor não quer que seja uma copia, pois precisaria deletar da lista favoritos e da lista normal. Tentei fazer uma função mas acho que esta faltando algo. A ideia que eu tive era pegar o endereço de memoria onde esse nome esta e excluir caso eu queira, ou buscar ele.

 

 

typedef struct CONTATO{
	char *nome;
	char *sobrenome;
	int numeroT;
	char *email;
	struct CONTATO *prox;
				
					
				}contato;



typedef struct FAVORITOS{
				
	struct contato * listadeContatos;
	struct Favoritos * prox;
						
				}favorito;





favorito *insercao_Fav(favorito *f, contato *c, char *nome, char *sobrenome){
		contato *contato_= c,*ant;
		favorito *favorito_ =(favorito*)malloc(sizeof(favorito));
		while(contato_!=NULL){
          ant = contato_
		if(nome == contato_->nome && sobrenome == contato_->sobrenome){
		favorito_->listadeContatos = contato_;
		favorito_->prox =ant;
					
		}else{
			ontato_=contato_->prox;
			}
					
		}
					return favorito;
	}
				

 

[Ansi C]

― Olá@Igor Vargas 

― Entendi! 

― Vou examinar algumas soluções aqui, não quero mais fica apenas com a primeira que vem a cabeça porque no geral essa é a menos didática, depois volto com a melhor explicação para post.

O.k!

[Igor Vargas]

@AnsiC Me confundi. É isso que devo fazer.

 

 

Favoritos: Uma outra lista, com ponteiros para os contatos favoritos deve ser criada.
Contatos marcados como favoritos na agenda devem ser adicionados ao final da lista
de favoritos. Contatos podem ser removidos apenas da lista de favoritos. Contatos
removidos da agenda, caso sejam favoritos, devem ser removidos dos favoritos. Por
fim, deve ser possível visualizar a lista dos contatos favoritos.

 

Dei uma editada no código, gostaria que você desse uma olhada, se der.

https://pastebin.com/7wcimDws

[Ansi C]

Olá @Igor Vargas

 

Em 29/09/2018 às 12:43, Igor Vargas disse:

Favoritos: Uma outra lista, com ponteiros para os contatos favoritos deve ser criada. Contatos marcados como favoritos na agenda devem ser adicionados ao final da lista de favoritos. Contatos podem ser removidos apenas da lista de favoritos. Contatos removidos da agenda, caso sejam favoritos, devem ser removidos dos favoritos. Por
fim, deve ser possível visualizar a lista dos contatos favoritos.

― Esse problema "é igual"/semelhante aos que você já fez aqui.

Trata-se de mais uma lista, iguais a que você já tem, com todas as funções de uma lista básica.

 

Funções Básicas em uma Lista - F.B.L:

1. item_novo(); // Criar um novo Item.
2. item_adicione(); // Adicionar um item ao Conjunto.
3. item_delete(); // Deletar um Item.
4. item_busque(); // Buscar um Item no Conjunto.
5. item_compare(); // Comparar dois Itens.
6. item_organize(); // Organizar (crescente; decrescente) o Conjunto.
7. item_visualize(); // Exibir um Item ou todo Conjunto.

 

Se você implementou essas funções, basta apenas mudar o nomes e poucas linhas de código porque a lógica entre elas é a mesma. No caso a estrutura Favoritos fica assim:

typedef struct Favorito {
	struct Contato  * meu_favorito; /*< Apenas um ponteiro para um contato. */
	struct Favorito * proximo;      /*< Próximo Favorito da Lista Atual. */
}
      favorito,  /*< Tipo variável para estrutura favorito. */
    * pfavorito; /*< Tipo ponteiro para estrutura favorito. */

Ou seja, cada nó (cada favorito) vai apontar para o local na memória daquele contato (1 por nó favorito) que se encontra na agenda e para o próximo favorito da lista.

 

 

Em 29/09/2018 às 12:43, Igor Vargas disse:

Contatos podem ser removidos apenas da lista de favoritos. Contatos
removidos da agenda, caso sejam favoritos, devem ser removidos dos favoritos.

Se para Contato você tem um função contato_delete(...), basta colocar dentro dessa função a função favorito_delete(...), assim sendo, todo contato deletado será também deletado na lista de favoritos, para achar o contato na lista de favoritos, use a função favorito_busque(...). Só cuido com relação a função favorito_delete(...), essa função deleta um nó favorito da lista favorita, o contato apontado pelo nó e de responsabilidade da FBL Contatos. De antemão, se teste com relação a FBL, e veja quais sabe adaptar a problema de Favoritos e quais não.

 

 

Em 29/09/2018 às 12:43, Igor Vargas disse:

Dei uma editada no código, gostaria que você desse uma olhada, se der

Sim, vou dar um olha, só que com calma por isso quando tiver mais tempo ainda hoje talvez.  Só lembrando que eu sou de C. Física e não de T. Informação! Então, pode ter muita coisa lá que em não vá gostar rsrsr, por uma questão cultural.

 

Algo mais a acrescentar ??
Pode falar O.k!

 

 

[Igor Vargas]

@AnsiC Entendi, de qualquer foma valeu pela ajuda, tenho uns 12 dia pra entregar ainda. O meu professor não ajudou muito com as explicações dele, ai to tentando me virar com o o que eu sei.

[Igor Vargas]

@AnsiC Não estou conseguindo fazer a parte de se a letra estiver sem contato.A letra ser  deletada.

 

letra_t *retira_letra(letra_t *l){
letra_t *p =l;
letra_t *ant=NULL;
while(p!=NULL){
ant = p;
p = p->prox;	
}
if(ant->prox = NULL){
l = p->prox;
	}else{
	ant->prox = p->prox;
		}
					
		return l;
				}
				

 

[Ansi C]

@Igor Vargas Essa rotina ela acontece da seguinte maneira.

 

1. Primeiro você deve determinar qual NÓ da agenda a deletar: Para isso você deve implementar / ou já ter um função que, por um letra passada no parâmetro, retorna o ponteiro NÓ anterior a essa letra.

Ex.

marcador= agenda_busque1('C'){ retorn B; }
// Daí a função começa a buscar: 1 compra com A, 2 compara com B, 3 depois compara com C.
// Achou C: retorna o que estava antes de C, ou seja retorna o NÓ B.

 

2. Como a função retorna um NÓ antes (B) daquele que vai ser excluído, que dizer que o que vem depois (B) é o que queremos excluir. Assim sendo, liga-se o NÓ anterior ao NÓ posteiro ao que vai ser excluir.

Ou seja, liga-se o NÓ (B) ao NÓ (D). Desta forma, temos como excluir o NÓ (C) da lista.

Ex.

marcador= agenda_busque1('C');
SE marcador != NULL ENTAO:
//  (?)     (B) -----> (C)
    delete= marcador->proximo;
    
//  (B) -----> (*)   = (C)---->(D)
    marcador->proximo= delete->proximo;
    
//      (C)
    free(delete);
    
// Com isso excluímos o NÓ (C) que vinha antes de marcador (B).
// Exatamente o que queriamos.

 

3. A lógica é a mesma para todas as lista, não esqueça disso.

Mais alguma coisa?

 

adicionado 12 minutos depois

HIT: não coloque o nome da classe / estrutura / objeto depois do método, porém sim o contrário: coloque o método depois da classe / estrutura / objeto.

 

Assim sendo: 

✘ letra_t *retira_letra(letra_t *l);
✔ letra_t *letra_retira(letra_t *l);

É mais bonito.

[Igor Vargas]

@AnsiCMais ou menos isso ?. Ta funcionando mas acho que estou retornando algo errado pois a lista fica vazia quando apago um contato da letra.

 

Função de busca

letra_t *busca_letra(letra_t *l, char nome){
letra_t *busca = l;
letra_t *ant=NULL;	
while(busca!=NULL){
ant = busca->prox;
if(busca->letra == nome){
return ant;
		}
	busca = busca->prox;
		}
				
		}
				

Função de retirar a letra. Caso não tenha nome com a letra inicial dela.

letra_t *letra_retira(letra_t *l,char nome){
	letra_t *p = l;
	letra_t *marcador =busca_letra(marcador,nome);
					
	if(marcador!=NULL){
	p = marcador->prox;
	marcador->prox = p->prox;
					}
	return l ;			
				}

 

[Ansi C]

― Eu não estou conseguindo determina onde começas e termina a função letra_t *busca_letra()

Edite o post e coloque cada uma em um bloco de código separado, assim:

 

letra_t *busca_letra()

...

 

letra_t *letra_retira(letra_t *l,char nome)

...

 

adicionado 34 minutos depois

@Igor Vargas Diga-me os erros.

 

Função busca

letra_t *busca_letra(letra_t *l, char nome){
    letra_t *busca= l->prox;
    letra_t *ant= l;	
    /*
         Ocorreu-me que o primeiro NÓ da lista pode ser
         o NÓ que estamos procurando, então tem uma situação
         especial para esse caso antes do laço:
         
         Antes do laço, uma outra expressão de controle retorna
         1 caso seja o primeiro NÓ da lista, o dito cujo.
    */
    if(l->letra == nome){ return 1; }
    while(busca != NULL){
        if(busca->letra == nome){
            return ant;
        }
	
        ant= busca;
        busca= busca->prox;
    }
    return NULL;
}

 

Função retira

letra_t *letra_retira(letra_t *l, char nome){
    letra_t *marcador= busca_letra(l, nome);
    letra_t *p= NULL;
    /*
         Se o NÓ com a letra for o primeiro da lista
         então marcador = 1 e será o primeiro IF, 
         senão então passa para o próximo IF.
    */
    if(marcador == 1){
        p= l;
        l= l->prox;
      
        free(p);
    } else
    if(marcador != NULL){
        p= marcador->prox;
        marcador->prox= p->prox;
        
        free(p);
    }
    return l;			
}

 

Aguardando.

O.k!

adicionado 51 minutos depois

Fiz um update do código.

[Igor Vargas]

@AnsiCAgora funcionou a parte de excluir. Estou tentando arrumar essa questão.

 

depois de inserido a primeira palavra fica assim.

 

i: igor.

Quando é inserido a segunda fica assim. Na exibição.

i: igor,joao.

j: joao.

 

[Ansi C]

 Impossível uma coisa dessas. 

Vou revisar agora, estou com tempinho.