Lista simplesmente encadeada tendo como argumento outra estrutura com dados

[Fah 0]

Boa Noite Pessoal!

Estou com dificuldade em implementar um exercício de lista simplesmente encadeada.  Nele pede para criar uma estrutura com os dados de um aluno (matricula, nome e media), e outra para ser a lista (com a estrutura com os dados do aluno e um no com as informações do próximo nó). Uma das opções é para inserir os dados de um novo aluno em ordem crescente de matricula. O código está dando erro. Vocês conseguem me dizer onde estou errando? Vejam meu código:

 

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
struct aluno{
    int matricula;
    char nome[100];
    float media;
};
typedef struct aluno Aluno;

struct no{
    Aluno* dados;
    struct no* prox;
};
typedef struct no No;
No* cria(No* l){
No* p=(No*)malloc(sizeof(No));
p->dados=NULL;
return l;
}
No* ins_ordenado(No* l,int mat,char* nome,float nota){
    Aluno* Al=(Aluno*)malloc(sizeof(Aluno));
    No* novo=(No*)malloc(sizeof(No));
    int i=0;
    Al->matricula=mat;
    while(nome!='\0'){
       Al->nome=nome;
       i++;
    }
    Al->nome=NULL;
    Al->media=nota;
    novo->dados=Al;
    No*p=l;
    No*aux=NULL;
    if(l==NULL){
        novo->prox=l;
        return novo;
    }
        while(p!=NULL&&p->dados->matricula<Al->matricula){
              aux=p;
              p=p->prox;
        }
        novo->prox=aux->prox;
        aux->prox=novo;
        if(p==NULL){
            novo->prox=NULL;
        }
    return l;
}
void imprime(No* l){
    No* p;
    printf("turma 1:\n");
    for(p=l;p!=NULL;p->prox){
        printf("Matricula: %d\t Nome: %s Nota:%f\n",p->dados->matricula,p->dados->nome,p->dados->media);
    }
    printf("\n");
}
int vazia(No* l){
    return(l==NULL);
}
int main(){
No* l1=cria(l1);
l1=ins_ordenado(l1,1,"Maria",5);
printf("vazia? %d",vazia(l1));
//imprime(l1);
return 0;
}

 

Desde já, Obrigada!

[_Isis_ 202]

Dica: ao invés de dizer que está dando erro, seria mais interessante dizer qual erro está dando. Muita coisa é sintaxe incorreta.

 

Antes de sair acessando e atribuindo coisas a ponteiros você faz bem em verificar se o retorno do malloc não é NULL.

Faz muito tempo que não mexo com C, então compila isso com os warnings ligados.

 

#include<stdio.h>
#include<stdlib.h>
#include<errno.h>
#include<string.h>

#define MAXNOME 100
struct aluno{
  int matricula;
  char nome[MAXNOME];
  float media;
};

typedef struct aluno Aluno;

struct no{
  Aluno* dados;
  struct no* prox;
};

typedef struct no No;

No* criar_lista(){
  No* tmp = (No*) malloc(sizeof(No));
  
  if (tmp == NULL) {
    printf("%s\n", strerror(errno));
    exit(1);
  }
  
  tmp->dados = NULL;
  tmp->prox = NULL;
  
  return tmp;
}

Aluno* criar_aluno() {
  Aluno* no_aluno = (Aluno*) malloc(sizeof(Aluno));
  if (no_aluno == NULL) {
    printf("%s\n", strerror(errno));
    exit(1);
  }
  return no_aluno;
}

Aluno* ler_aluno() {
  
  Aluno* no_aluno = criar_aluno();
  
  printf("Informe a matrícula:");
  scanf("%d%*c", &(no_aluno->matricula));
  
  printf("Informe o nome:");
  fgets(no_aluno->nome, 100, stdin);
  (*strrchr(no_aluno->nome, '\n')) = '\0';
  
  printf("Informe a média:");
  scanf("%f", &(no_aluno->media));
  
  return no_aluno;
}

No* inserir_ordenado(No* lista_alunos, Aluno* aluno) {
  if(lista_alunos == NULL) {
    return -1;
  }
  
  int posicao = 0;
  No* elemento = lista_alunos;
  No* anterior = NULL;
  if (elemento->dados == NULL && elemento->prox == NULL) {
    lista_alunos->dados = aluno;
  
  } else {
    
    while (elemento != NULL && elemento->dados->matricula < aluno->matricula) {
      anterior = elemento;
      elemento = elemento->prox;
    }
    
    No * tmp = (No*) malloc(sizeof(No));
    if (tmp == NULL) {
      printf("%s",strerror(errno));
      free(lista_alunos);
      free(aluno);
      exit(1);
    }
    
    tmp->dados = aluno;
    
    if (anterior == NULL) {
      tmp->prox = lista_alunos;
      return tmp;
    } else {
      if (elemento == NULL) {
        tmp->prox = NULL;
        anterior->prox = tmp;
      } else {
        tmp->prox = elemento;
        anterior->prox = tmp;
      }
    }
  }
  
  return lista_alunos;
}

void imprimir(const No* lista_alunos) {
  No* tmp = lista_alunos;
  while(tmp != NULL) {
    if (tmp->dados != NULL) {
      printf("Nome:%s\tMatrícula:%d\tMédia:%.2f\n", tmp->dados->nome, tmp->dados->matricula, tmp->dados->media);
    }
    tmp = tmp->prox;
  }
}

void desalocar(No* l) {
  if (l->prox == NULL) {
    free(l);
    return;
  } else {
    desalocar(l->prox);
    free(l);
  }
}
int main(){
  No* lista_alunos = criar_lista();
  imprimir(lista_alunos);
  
  Aluno * aluno;
  
  for(int i =0 ; i<5; i++) {
    aluno = ler_aluno();
    lista_alunos = inserir_ordenado(lista_alunos, aluno);
  }
  
  imprimir(lista_alunos);
  
  
  free(aluno);
  desalocar(lista_alunos);
  return 0;
}

 

[Wilkyn Fernandes Taborda 0]

Fah em:

while ( nome!= '\0' ){
Al-> nome= nome;
i ++;
}
Al-> nome= NULL;

Dá erro pois faltam os índices que apontam qual caractére se está a copiar. Faz-se:

while ( nome[i]!= '\0' ){
Al-> nome[i]= nome[i];
i ++;
}
Al-> nome[i]= NULL;

A função cria está errada. Ela retorna o valor do ponteiro que foi passado como argumento sem modificar o valor da região para aonde ele aponta. Isso não é erro porém redundante. O erro está em que a nova lista criada pela função se perde na memória após a função terminar e não se tem controle sobre a nova lista criada.

 

O programa trava ao executar por que na função principal falta inicializar a variável l1 com o valor nulo para que a função de inserção ordenada saiba que a lista está vazia. É:

l1=NULL;

A função de inserção ordenada é redundante pois além de inserir o novo elemento na lista ainda retorna um ponteiro para essa mesma lista. Não está errado mas isso se torna desnecessário a partir da inserção do segundo elemento da lista e em diante até que se resolva adicionar algum com número de matrícula menor do que todos os outros.

 

O programa vai travar toda vez que inserir um valor com número de matrícula menor do que todos os outros que já tem na lista. Isso por que o ponteiro próximo apontado pelo ponteiro novo na função inserção ordenada está recebendo como apontamento outro ponteiro próximo de um valor nulo que não existe e o ponteiro aux da mesma função está sendo ordenado em seu membro apontado ponteiro próximo a apontar para algo que ele não pode por o valor de aux ser nulo e seus membros apontados não existirem. Para resolver isso coloca-se uma variável contadora de elementos da lista com número de matrícula menor do que o que está sendo inserido. Se o resultado do contador for 0 aponta-se o início da lista para o novo elemento e o ponteiro próximo do novo elemento para a lista atual aonde já estarão os outros elementos consecutivos.

 

A função imprime fica para sempre imprimindo somente a primeira matrícula repetidas vezes por que não foi colocado a linha de código que faz o ponteiro p avançar para o próximo da lista que é:

p=p->prox;

Nenhuma função da biblioteca string é usada. A linha que a adiciona pode ser removida.

 

O mesmo programa porém com essas modificações que eu disse fica:

#include <stdio.h>

struct aluno {
int matricula ;
char nome [ 100 ];
float media ;
};
typedef struct aluno Aluno ;
struct no {
Aluno * dados ;
struct no * prox ;
};
typedef struct no No;
No* ins_ordenado ( No* l , int mat , char* nome , float nota ){
int contadora;

Aluno * Al=( Aluno *)malloc
( sizeof( Aluno ));
No* novo =( No*)malloc( sizeof
( No));
int i = 0 ;
Al-> matricula = mat ;
while ( nome[i]!= '\0' ){
Al-> nome[i]= nome[i];
i ++;
}
Al-> nome[i]= NULL;
Al-> media = nota;
novo -> dados = Al;
No* p = l ;
No* aux = NULL;
if( l ==NULL){
novo -> prox= l ;
return novo ;
}
contadora=0;
while ( p != NULL&&p -> dados -> matricula < Al-> matricula ){
aux = p ;
p = p -> prox;
contadora++;
}
if(contadora>0){
novo -> prox= aux -> prox;
aux -> prox= novo;
}
else{
novo->prox=l;
l=novo;
return l;
}
if( p ==NULL){
novo -> prox= NULL;
}
return l ;
}
void imprime ( No* l ){
No* p ;
printf ( "turma 1:\n" );
for ( p = l ; p != NULL; p -> prox){
printf ( "Matricula: %d\t Nome: %s Nota:%f\n" , p -> dados -> matricula , p -> dados -> nome, p -> dados -> media );
p=p->prox;
}
printf ( "\n" );
}
int vazia ( No* l ){
return( l ==NULL);
}
int main (){
No* l1;
l1=NULL;
l1 = ins_ordenado ( l1 , 1 , "Maria" , 5 );
ins_ordenado ( l1 , 2 , "Joao" , 10 );
ins_ordenado ( l1 , 3 , "Jose" , 6 );
ins_ordenado ( l1 , 5 , "Joaquim" , 7 );
ins_ordenado ( l1 , 4 , "Manoel" , 8 );
l1=ins_ordenado ( l1 , 0 , "Felipe" , 9 );

printf( "vazia? %d" , vazia ( l1 ));
imprime(l1);
system("pause");
return 0 ;
}