Lista simplesmente encadeada tendo como argumento outra estrutura com dados

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

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