fork download
copy 
  1. #include <locale.h> 
  2. #include <stdlib.h> 
  3. #include <stdio.h> 
  4. #include <string.h>
  5.  
  6. struct aluno
  7. {
  8.   int codigo;
  9.   char nome[50];
  10.   char curso[35];
  11. };
  12.  
  13. struct listaAluno
  14. {
  15.   struct aluno aluno;
  16.   struct listaAluno *proximo;
  17.   struct listaLivro *inicLivro;
  18. };
  19.  
  20. struct livro
  21. {
  22. 	int codigo;
  23. 	char titulo[50];
  24. 	char autor[40];
  25. };
  26.  
  27. struct listaLivro
  28. {
  29. 	struct livro info;
  30. 	struct listalivro *proximo;
  31. };
  32.  
  33. /*
  34.  * Estrutura do tipo aluno primária
  35.  */
  36. struct listaAluno* insereInicio(struct listaAluno *inicio, struct aluno x){
  37. 	struct listaAluno *aux;
  38.   	aux = (struct listaAluno*)malloc(sizeof(struct listaAluno));
  39.   	aux->aluno = x;
  40.   	aux->proximo = inicio;
  41.   	inicio = aux;
  42.   	return inicio;
  43. }
  44.  
  45. struct listaAluno* removeInicio(struct listaAluno *inicio){
  46.   	struct listaAluno *aux;
  47.   	aux = inicio;
  48.   	inicio = inicio->proximo;
  49.   	free(aux);
  50.   	return inicio;
  51. }
  52.  
  53. void insereDepois(struct listaAluno *l, struct aluno x){
  54.   	struct listaAluno *aux;
  55.   	aux=(struct listaAluno*)malloc(sizeof(struct listaAluno));
  56.   	aux->aluno = x;
  57.   	aux->proximo = l->proximo;
  58.   	l->proximo = aux;
  59. }
  60.  
  61. void removeDepois(struct listaAluno *l){
  62.   	struct listaAluno *aux;
  63.   	aux = l->proximo;
  64.   	l->proximo = aux->proximo;
  65.   	free(aux);
  66. }
  67.  
  68. struct listaAluno* insereOrdenado(struct listaAluno *inicio, struct aluno x)
  69. {
  70.   	struct listaAluno *p, *q;
  71.   	p = inicio;
  72.   	if((p == NULL) || (x.codigo < p->aluno.codigo))
  73. 	{
  74.    		inicio = insereInicio(inicio , x);
  75.     	return inicio;
  76.   	}
  77.  
  78. 	  q = p;
  79.  
  80. 	while((q != NULL) && (q->aluno.codigo < x.codigo))
  81. 	{
  82.     	p = q;
  83.     	q = p->proximo;
  84.   	}
  85.   	if((q == NULL) || (q->aluno.codigo > x.codigo))
  86.     	insereDepois(p, x);
  87.   	else
  88.    		printf("\nAluno já cadastrado");
  89.     return inicio;
  90. }
  91.  
  92. struct listaAluno* removeOrdenado(struct listaAluno *inicio, int x)
  93. {
  94.   	struct listaAluno *p, *q;
  95.   	p = inicio;
  96.  
  97.   	if(p == NULL)
  98. 	{
  99. 	    printf("\nLista vazia\n");
  100. 	    getchar();
  101.     	return inicio;
  102.   	}
  103.  
  104.   	if(x == p->aluno.codigo)
  105. 	{
  106.     inicio = removeInicio(inicio);
  107.     return inicio;
  108.   	}
  109.  
  110.   	q = p;
  111.  
  112.   	while((q != NULL) && (q->aluno.codigo < x))
  113. 	{
  114.     	p = q;
  115.     	q = p->proximo;
  116.   	}
  117.  
  118.   	if((q != NULL) && (q->aluno.codigo == x))
  119.    		removeDepois(p);
  120.   	else 
  121. 	{
  122.     	printf("\nAluno não Cadastrado");
  123.     	getchar();
  124.   	}   
  125.  
  126.   	return inicio;
  127. }
  128.  
  129. /* 
  130.  * Cria uma struct do tipo estudante, para posteriormente 
  131.  * ordenar os alunos.
  132.  */
  133. struct aluno criaAluno(char nome[50], int cod, char curso[35])
  134. {
  135. 	struct aluno estudante;
  136.  
  137. 	estudante.codigo = cod;
  138. 	strcpy(estudante.nome, nome);
  139. 	strcpy(estudante.curso, curso);
  140.  
  141. 	return estudante;
  142. }
  143. /* 
  144.  * Entrada de dados para definir os valores do aluno, 
  145.  * chama (criaAluno) para fazer a struct e (insereOrdenado)
  146.  * para criar a struct de listaAluno.
  147.  */
  148. struct listaAluno* incluiAluno(struct listaAluno *inicio)
  149. {
  150. 	char nome[50], curso[35];
  151. 	int codigo, cont, esc;
  152.  
  153. 	cont = 0;
  154. 	while(cont == 0){
  155.  
  156. 		printf("Cadastro de alunos\n");
  157. 		printf("Nome Completo: ");
  158. 		scanf("%s", &nome);
  159. 		printf("Código: ");
  160. 		scanf("%i", &codigo);
  161. 		printf("Curso:");
  162. 		scanf("%s", &curso);	
  163.  
  164. 		inicio = insereOrdenado(inicio, criaAluno(nome, codigo, curso));
  165.  
  166. 		printf("Deseja cadastrar outro aluno? (1 SIM | 2 NÃO): ");
  167. 		scanf("%i", &esc);
  168.  
  169. 		if(esc == 2)
  170. 			cont = 1;
  171. 	}
  172. 	return inicio;
  173. }
  174. /* 
  175.  * Exclui aluno cadastro atraves de um código informado, 
  176.  * Caso o aluno possuir livros em sua conta, o mesmo não
  177.  * pode ser excluido.
  178.  * OBS. BUG -> loop infinito, não estou achando o erro.
  179.  */
  180. struct listaAluno* removeAluno(struct listaAluno *inicio)
  181. {
  182. 	struct listaAluno *aux;
  183. 	int cod_aluno;
  184.  
  185. 	printf("Excluir Aluno\n");
  186. 	printf("Informe o Código:");	
  187. 	scanf("%i", &cod_aluno);
  188.  
  189. 	aux = inicio;
  190. 	while(aux != NULL)
  191. 	{
  192. 		if((cod_aluno == aux->aluno.codigo)&&(aux->inicLivro != NULL))
  193. 			inicio = removeOrdenado(inicio, cod_aluno);
  194. 		else
  195. 			printf("O aluno não pode ser removido, pois possui livros em sua conta.");
  196.  	}		
  197.  	return inicio;
  198. }
  199. /* 
  200.  * Exibe todos os alunos cadastrados no sistema.
  201.  */
  202. void mostraAlunos(struct listaAluno *inicio)
  203. {
  204. 	struct listaAluno *aux;
  205. 	aux = inicio;
  206.  
  207. 	if(aux == NULL)
  208. 		printf("Nenhum aluno cadastrado.");
  209.  	else
  210.  	{
  211.  		printf("Lista de alunos cadastrados:\n");
  212. 		while(aux != NULL)
  213. 		{
  214. 		 	printf("Código: %d | Nome: %s | Curso: %s\n", aux->aluno.codigo, aux->aluno.nome, aux->aluno.curso);
  215. 			aux = aux->proximo;
  216. 		}
  217. 	}
  218. }
  219. /* 
  220.  * A partir de um código, procura o aluno no sistema
  221.  * e exibe caso o encontre.
  222.  * OBS. BUG -> Caso haja alunos cadastrados no sistema,
  223.  * mas o código informado não seja de nenhum mensagem do ultimo
  224.  * IF não é exibida.
  225.  */
  226. void buscaAluno(struct listaAluno *inicio)
  227. {
  228. 	struct listaAluno *aux;
  229. 	int cod_aluno;
  230. 	int cot;
  231.  
  232. 	cot = 0;
  233. 	aux = inicio;
  234.  
  235. 		if(aux == NULL)
  236. 	{
  237. 		printf("Não há alunos cadastrados no sistema.");
  238. 		printf("\nImpossivel realizar consulta.");
  239. 	}
  240. 	else
  241. 	{
  242. 		printf("\nLocalizar Aluno\n");
  243. 		printf("Informe o código do aluno: ");
  244. 		scanf("%i", &cod_aluno);
  245.  
  246. 	 	while(aux != NULL)
  247. 		{ 
  248. 	 		if(cod_aluno == aux->aluno.codigo)
  249. 			{
  250. 	 			printf("\nCódigo: %d | Nome: %s | Curso: %s",  aux->aluno.codigo, aux->aluno.nome, aux->aluno.curso);
  251. 			 	cot = 1;
  252. 	    	}	
  253. 			aux = aux->proximo;
  254. 		}
  255. 	}
  256.  
  257.   	if((aux != NULL)&&(cot == 0))
  258.   	{
  259.     	printf("O código informado não pertece a nenhum aluno cadastrado no sistema.");
  260. 	}
  261. }
  262.  
  263. /*
  264.  * Estrutura do tipo livro primária
  265.  */
  266. struct listaLivro* insereInicioLivro(struct listaLivro *inicio, struct livro x){
  267. 	struct listaLivro *aux;
  268.   	aux = (struct listaLivro*)malloc(sizeof(struct listaLivro));
  269.   	aux->info = x;
  270.   	aux->proximo = inicio->proximo;
  271.   	inicio = aux;
  272.   	return inicio;
  273. }
  274.  
  275. struct listaLivro* removeInicioLivro(struct listaLivro *inicio){
  276.   	struct listaLivro *aux;
  277.   	aux = inicio;
  278.   	inicio->proximo = inicio->proximo;
  279.   	free(aux);
  280.   	return inicio;
  281. }
  282.  
  283. void insereDepoisLivro(struct listaLivro *l, struct livro x){
  284.   	struct listaLivro *aux;
  285.   	aux=(struct listaLivro*)malloc(sizeof(struct listaLivro));
  286.   	aux->info = x;
  287.   	aux->proximo = l->proximo;
  288.   	l->proximo = aux->proximo;
  289. }
  290.  
  291. void removeDepoisLivro(struct listaLivro *l){
  292.   	struct listaLivro *aux;
  293.   	aux->proximo = l->proximo;
  294.   	l->proximo = aux->proximo;
  295.   	free(aux);
  296. }
  297.  
  298. struct listaLivro* insereOrdenadoLivro(struct listaLivro *inicio, struct livro x){
  299.   	struct listaLivro *p, *q;
  300.  
  301. 	p = inicio;
  302.  
  303. 	if((p == NULL) || (x.codigo < p->info.codigo)){
  304.     	inicio = insereInicioLivro(inicio, x);
  305.     	return inicio;
  306.   	}
  307.  
  308.   	q = p;
  309.  
  310.   	while((q != NULL) && (q->info.codigo < x.codigo)){
  311.     	p = q;
  312.     	q->proximo = p->proximo;
  313.   	}
  314.  
  315.   	if((q == NULL) || (q->info.codigo > x.codigo))
  316.     	insereDepoisLivro(p, x);
  317.   	else
  318.     	printf("\nElemento já Existe");
  319.  
  320.     return inicio;
  321. }
  322.  
  323. struct listaLivro* removeOrdenadoLivro(struct listaLivro *inicio, struct livro x){
  324.   	struct listaLivro *p, *q;
  325.   	p = inicio;
  326.  
  327.   	if(p == NULL){
  328. 	    printf("\nLista vazia\n");
  329. 	    getchar();
  330.     return inicio;
  331.   	}
  332.  
  333.   	if(x.codigo == p->info.codigo){
  334.     inicio = removeInicioLivro(inicio);
  335.     return inicio;
  336.   	}
  337.  
  338.   	q = p;
  339.  
  340.   	while((q != NULL) && (q->info.codigo < x.codigo)){
  341.     	p = q;
  342.     	q->proximo = p->proximo;
  343.   	}
  344.  
  345.   	if((q != NULL) && (q->info.codigo == x.codigo))
  346.    		removeDepoisLivro(p);
  347.   	else {
  348.     	printf("\nElemento nao Cadastrado");
  349.     	getchar();
  350.   	}   
  351.  
  352.   	return inicio;
  353. }
  354.  
  355. /*
  356.  * Inicio da criação de livros e inicio dos principais erros
  357.  */
  358.  
  359. /* 
  360.  * Cria a estrutura de dados do tipo Livro 
  361.  */
  362. struct livro criaLivro(char titulo[50], int cod, char autor[40])
  363. {
  364. 	struct livro l;
  365.  
  366. 	l.codigo = cod;
  367. 	strcpy(l.autor, autor);
  368. 	strcpy(l.titulo, titulo);
  369.  
  370. 	return l;
  371. }
  372. /* 
  373.  * Entrada de dados para definir os valores do aluno, 
  374.  * verifica se determinado aluno existe, 
  375.  * caso exista chama (insereOrdenado) passando como referencia 
  376.  * (auxLivro[inicio do livro]) e (criaLivro[para criar a estrutura do tipo Livro]);
  377.  */
  378. struct listaAluno* incluiLivro(struct listaAluno* inicio)
  379. {
  380. 	struct listaAluno *auxAluno;
  381. 	struct listaLivro *auxLivro;
  382. 	char autor[40], titulo[50];
  383. 	int codigo, cod_aluno, cont;
  384.  
  385. 	cont = 0;
  386. 	auxAluno = inicio;
  387. 	auxLivro = inicio->inicLivro;
  388.  
  389. 	printf("\nIncluir livro\n");
  390. 	printf("Informe o código do aluno: ");
  391. 	scanf("%i", &cod_aluno);
  392.  
  393. 	if(auxAluno == NULL)
  394. 	{
  395. 		printf("Nenhum aluno cadastrado no sistema.");
  396. 	}
  397. 	else
  398. 	{
  399. 	 	while(auxAluno != NULL)
  400. 		{ 
  401. 	 		if(cod_aluno == auxAluno->aluno.codigo)
  402. 			{
  403. 				printf("\Dados do livro\n");
  404. 				printf("Código: ");
  405. 				scanf("%i", &codigo);
  406. 				printf("Título: ");
  407. 				scanf("%s", &titulo);
  408. 				printf("Autor:");
  409. 				scanf("%s", &autor);
  410. 				auxLivro = insereOrdenadoLivro(auxLivro, criaLivro(titulo, codigo, autor));
  411. 				auxAluno->inicLivro = auxLivro;
  412. 			 	cont = 1;
  413. 	    	}	
  414. 		}
  415. 	}
  416.  
  417.   	if((auxAluno != NULL)&&(cont == 0))
  418.   	   	printf("O código informado não pertece a nenhum aluno cadastrado no sistema.");
  419. }
  420.  
  421. main() 
  422. {
  423. 	setlocale(LC_ALL, "Portuguese");
  424. 	struct listaAluno *inicio = NULL;
  425. 	int opcAluno, exitMenu, opcLivro;
  426. 	int cod_aluno, cod_livro;
  427.  
  428. 	// MENU 
  429. 	while (exitMenu == 0)
  430. 	{
  431. 		printf("1: Incluir Aluno");
  432. 		printf("\n5: Incluir Livro");
  433. 		printf("\n4: Buscar Aluno");
  434. 		printf("\n3: Exibir Alunos");
  435. 		printf("\n6: Exibir Livros do Aluno");
  436. 		printf("\n2: Excluir Aluno");
  437. 		printf("\n7: Excluir Livro do Aluno");
  438. 		printf("\n8: Bônus -> Excluir ultimo aluno");
  439. 		printf("\n9: Sair");
  440. 		printf("\n\nO que deseja fazer: ");
  441. 		scanf("%d", &opcAluno);
  442. 		printf("\n");
  443. 		switch(opcAluno)
  444. 		{
  445. 			case 1:
  446. 		   		inicio = incluiAluno(inicio);
  447. 		     	break;
  448.  
  449. 			case 2:
  450. 				removeAluno(inicio);
  451. 				break;
  452.  
  453. 			case 3:
  454. 				mostraAlunos(inicio);
  455. 				break;
  456.  
  457. 			case 4:
  458. 				buscaAluno(inicio);
  459. 				break;
  460.  
  461. 			case 5:
  462. 				incluiLivro(inicio);
  463. 				break;
  464.  
  465. 			case 9:
  466. 				exitMenu = 1;
  467. 				break;
  468.  
  469. 			default :
  470.        			printf ("Valor invalido!");
  471. 		}
  472.  
  473. 		if(exitMenu == 1)
  474. 			printf("Operação terminada.");
  475. 		else
  476. 			printf("\n\n");
  477. 	}
  478.  
  479. }
Success #stdin #stdout 0s 2300KB
comments (?)
stdin
copy 
Standard input is empty
stdout
copy 
Standard output is empty
https://ideone.com/OhMSXo
language:
C (gcc 8.3)
created:
7 years ago
visibility:
public

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!