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