Guest User

Untitled

a guest
Oct 17th, 2017
60
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 10.61 KB | None | 0 0
  1. #include "stdafx.h"
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <ctype.h>
  5. #include <string.h>
  6. #define MAX_PALAVRA 50 // Tamanho maximo para o nome!
  7. #define MAX_LINGUA 2
  8. #define LINGUA "PT"
  9. #define NOME_FICHEIRO "PT.txt"
  10.  
  11. //estrutura palavra
  12. typedef struct Palavra {
  13. char texto[MAX_PALAVRA];
  14. } *PALAVRA;
  15.  
  16. typedef struct Elemento {
  17. PALAVRA inf;
  18. struct Elemento *seg;
  19. } *ELEMENTO;
  20.  
  21. typedef struct Lista {
  22. char lingua[MAX_LINGUA]; /* a) */
  23. int nelementos; /* b */
  24. ELEMENTO inicio; /* c */
  25. } *LISTA;
  26.  
  27. LISTA criar_lista(){
  28. LISTA L;
  29. L = (LISTA)malloc(sizeof(struct Lista));
  30. if(!L){
  31. printf("\n Memoria insuficiente");
  32. L->inicio = NULL;
  33. L->nelementos = 0;
  34. return L;
  35. }
  36. }
  37. ELEMENTO criar_elemento(){
  38. ELEMENTO E = (ELEMENTO) malloc(sizeof(struct Elemento));
  39. E->inf = (PALAVRA) malloc(sizeof(struct Palavra));
  40. E->seg = NULL;
  41. return E;
  42. }
  43.  
  44. int validar_elemento(ELEMENTO E) {
  45. char *palavra = E->inf->texto;
  46.  
  47. for (int i=0;i<strlen(palavra);i++)
  48. if (palavra[i]<0 || palavra[i]>128 || !isalpha(palavra[i]))
  49. return 0;
  50. return 1;
  51. }
  52.  
  53. void ler_elemento(ELEMENTO E) {
  54. int elemento_valido;
  55. do {
  56. printf("Palavra: ");
  57. scanf("%s", E->inf->texto);
  58.  
  59. if (!(elemento_valido = validar_elemento(E)))
  60. printf("Introduza apenas letras [a-zA-z] sem caracteres acentuados.\n");
  61.  
  62. } while (!elemento_valido);
  63. }
  64. int comparar_elementos(ELEMENTO A, ELEMENTO B) {
  65.  
  66. PALAVRA PA = (PALAVRA) A->inf, PB = (PALAVRA) B->inf;
  67. return strcmp(PA->texto, PB->texto); // Verificar se A=B através do texto
  68. }
  69.  
  70. int elementos_iguais(ELEMENTO A, ELEMENTO B) {
  71. return comparar_elementos(A,B)==0;
  72. }
  73.  
  74. void inserir_elemento_ordenado(LISTA L, ELEMENTO ele_novo) {
  75. if (!L || !ele_novo)
  76. return;
  77.  
  78. int av=1;
  79. ELEMENTO ant,act;
  80.  
  81. if (L->inicio==NULL) {
  82. ele_novo->seg=NULL;
  83. L->inicio=ele_novo;
  84. } else {
  85. ant=act=L->inicio;
  86. while(av)
  87. if(act==NULL)
  88. av=0;
  89. else if(comparar_elementos(act, ele_novo)>0)
  90. av=0;
  91. else {
  92. ant=act;
  93. act=act->seg;
  94. }
  95.  
  96. if(act==L->inicio) {
  97. ele_novo->seg=L->inicio;
  98. L->inicio=ele_novo;
  99. }
  100. else {
  101. ant->seg=ele_novo;
  102. ele_novo->seg=act;
  103. }
  104. }
  105. L->nelementos++;
  106. }
  107.  
  108. ELEMENTO pesquisar_iterativo(LISTA L, ELEMENTO ele_pesquisa) {
  109.  
  110. if (!ele_pesquisa || !L)
  111. return NULL;
  112.  
  113. ELEMENTO aux = L->inicio;
  114. while (aux) {
  115. if (elementos_iguais(aux, ele_pesquisa))
  116. return aux;
  117. else
  118. aux = aux->seg;
  119. }
  120. return NULL;
  121. }
  122.  
  123. ELEMENTO pesquisar_recursivo_elemento(ELEMENTO C, ELEMENTO ele_pesquisa) {
  124. if (!C)
  125. return NULL;
  126. if (elementos_iguais(C, ele_pesquisa))
  127. return C;
  128. else
  129. return pesquisar_recursivo_elemento(C->seg, ele_pesquisa);
  130. }
  131.  
  132. ELEMENTO pesquisar_recursivo(LISTA L, ELEMENTO ele_pesquisa) {
  133. if (!L || !ele_pesquisa)
  134. return NULL;
  135. return pesquisar_recursivo_elemento(L->inicio, ele_pesquisa);
  136. }
  137.  
  138. int elementos_repetidos(LISTA L) {
  139. if (!L)
  140. return 0;
  141.  
  142. ELEMENTO cmp = NULL;
  143. ELEMENTO ref = L->inicio;
  144. while (ref->seg) {
  145. cmp=ref->seg;
  146. while (cmp) {
  147. if (elementos_iguais(ref, cmp))
  148. return 1;
  149. else
  150. cmp=cmp->seg;
  151. }
  152. ref=ref->seg;
  153. }
  154. return 0;
  155. }
  156.  
  157. void libertar_elemento(ELEMENTO ele_libertar) {
  158. free(ele_libertar->inf); // Destroi informacao
  159. free(ele_libertar); // Destroi o elemento
  160. }
  161.  
  162. ELEMENTO remover_elemento(LISTA L, ELEMENTO ele_remover) {
  163.  
  164. if (!L)
  165. return NULL;
  166.  
  167. int av=1;
  168. ELEMENTO ret,ant,act;
  169. if (L->inicio==NULL)
  170. ret=NULL;
  171. else {
  172. ant=act=L->inicio;
  173. while(av)
  174. if(act==NULL)
  175. av=0;
  176. else if(elementos_iguais(act, ele_remover))
  177. av=0;
  178. else {
  179. ant=act;
  180. act=act->seg;
  181. }
  182.  
  183. if(act!=NULL) {
  184. ret=act;
  185. if(L->inicio==act)
  186. L->inicio=act->seg;
  187. else
  188. ant->seg=act->seg;
  189. L->nelementos--;
  190. }else
  191. ret=NULL;
  192. }
  193. return ret;
  194. }
  195. ELEMENTO remover_primeiro(LISTA L) {
  196. if (!L)
  197. return NULL;
  198. ELEMENTO p = L->inicio;
  199. if (p) {
  200. L->inicio = p->seg;
  201. L->nelementos--;
  202. return p;
  203. }
  204. return NULL;
  205. }
  206.  
  207. ELEMENTO remover_ultimo(LISTA L) {
  208. if (!L)
  209. return NULL;
  210. // Temos de ir andando na Lista e quando chegar ao Fim....
  211. // Temos de ter sempre um ponteiro para o anterior ...
  212. // Caso em que a Lista tem elementos!
  213. ELEMENTO ant = NULL;
  214. ELEMENTO p = L->inicio;
  215. while (p->seg) {
  216. ant = p;
  217. p = p->seg;
  218. }
  219. // Repare-se que ant e um ponteiro para o penultimo elemento da lista!
  220. if (ant) // a lista tem mais do que um elemento!
  221. ant->seg = NULL;
  222. else
  223. L->inicio = NULL;
  224.  
  225. L->nelementos--;
  226. return p;
  227. }
  228.  
  229. void mostrar_elemento(ELEMENTO ele_mostrar) {
  230. printf("%s",ele_mostrar->inf->texto);
  231. }
  232.  
  233. void mostrar_ordenado(LISTA L) {
  234. if (!L)
  235. return;
  236. ELEMENTO p = L->inicio;
  237.  
  238. while (p) {
  239. mostrar_elemento(p);
  240. printf(" ");
  241. p = p->seg;
  242. }
  243. }
  244.  
  245. void mostrar_ordenado_inversa(ELEMENTO p) {
  246. if (p) {
  247. mostrar_ordenado_inversa(p->seg);
  248. mostrar_elemento(p);
  249. printf(" ");
  250. }:;:_kojnkl
  251. }
  252. void mostrar_inversa(LISTA L) {
  253. if (!L)
  254. return;
  255. mostrar_ordenado_inversa(L->inicio);
  256. }
  257.  
  258. void destruir(LISTA L) {
  259. if (!L)
  260. return;
  261. // Destroi a Lista e toda a informação que ela contêm
  262. ELEMENTO p = L->inicio;
  263. while (p) {
  264. ELEMENTO ant = p;
  265. p = p->seg;
  266. libertar_elemento(ant);
  267. }
  268. L->inicio = NULL;
  269. L->nelementos = 0;
  270. }
  271. void exportar_ficheiro(LISTA L, char *nome_ficheiro) {
  272. if (!L)
  273. return;
  274. FILE *f = fopen(nome_ficheiro, "w");
  275. fprintf(f, "%d\n", L->nelementos);
  276. ELEMENTO p = L->inicio;
  277. while (p) {
  278. fprintf(f, "%s\n",p->inf->texto);
  279. p = p->seg;
  280. }
  281. fclose(f);
  282. }
  283. void importar_ficheiro(LISTA L, char *nome_ficheiro) {
  284. if (!L)
  285. return;
  286. FILE *f = fopen(nome_ficheiro, "r");
  287. if (!f) {
  288. printf("Nao foi possivel Abrir o Ficheiro!\n");
  289. return; // Para o caso em que nao foi possivel abrir o ficheiro!
  290. }
  291. int nelementos;
  292. fscanf(f, "%d", &nelementos);
  293.  
  294. for (int i = 0; i < nelementos; i++) {
  295. ELEMENTO P = criar_elemento();
  296. fscanf(f, "%s", P->inf->texto);
  297. inserir_elemento_ordenado(L, P);
  298. }
  299. fclose(f);
  300. }
  301. char menu_principal() {
  302. char x;
  303. printf("\n # MENU PRINCIPAL -----------------------------------------#");
  304. printf("\n | (1) Inserir um novo elemento na lista |");
  305. printf("\n | (2) Retirar elementos da lista (+) |");
  306. printf("\n | (3) Mostrar os elementos pela ordem actual |");
  307. printf("\n | (4) Mostrar os elementos pela ordem inversa |");
  308. printf("\n | (5) Mostrar o numero de elementos da lista |");
  309. printf("\n | (6) Pesquisar por um elemento da lista |");
  310. printf("\n | (7) Verificar se existem elementos repetidas na lista |");
  311. printf("\n | (8) Exportar elementos para um ficheiro de texto |");
  312. printf("\n | (9) Importar elementos de um ficheiro de texto |");
  313. printf("\n | ----------------------------------------------------- |");
  314. printf("\n | (0) SAIR |");
  315. printf("\n #---------------------------------------------------------#\n");
  316. fflush(stdin);
  317.  
  318. do {
  319. printf("\n Qual a sua opcao ? ");
  320. fflush(stdin);
  321. x=getchar();
  322. } while (x<'0' || x>'9');
  323. return x;
  324. }
  325. char menu_remover() {
  326. char x;
  327. printf("\n # RETIRAR ELEMENTOS DA LISTA ----------------------------#");
  328. printf("\n | (1) Retirar o primeiro elemento |");
  329. printf("\n | (2) Retirar um elemento especificado pelo utilizador |");
  330. printf("\n | (3) Retirar o ultimo elemento |");
  331. printf("\n | (4) Retirar todos os elementos da lista |");
  332. printf("\n | ---------------------------------------------------- |");
  333. printf("\n | (0) VOLTAR |");
  334. printf("\n #--------------------------------------------------------#\n");
  335. fflush(stdin);
  336. do {
  337. printf("\n Qual a sua opcao ? ");
  338. fflush(stdin);
  339. x=getchar();
  340. } while (x<'0' || x>'4');
  341. return x;
  342. }
  343.  
  344. void main() {
  345. ELEMENTO ele_remover, ele_removido, ele_pesquisar, ele_novo;
  346. LISTA lista = criar_lista(); // Criar a lista
  347. strcpy(lista->lingua, LINGUA); // Associar a lingua a lista
  348. for(;;) {
  349. system("cls");
  350. switch (menu_principal()) {
  351. case '1':
  352. ele_novo = criar_elemento();
  353. ler_elemento(ele_novo);
  354. inserir_elemento_ordenado(lista, ele_novo);
  355. break;
  356. case '2':
  357. switch (menu_remover()) {
  358. case '1':
  359. ele_removido = remover_primeiro(lista);
  360. if (ele_removido) {
  361. printf("Foi removido o primeiro elemento");
  362. mostrar_elemento(ele_removido);
  363. libertar_elemento(ele_removido);
  364. }else
  365. printf("Não foi encontrado nenhum elemento!\n");
  366. break;
  367. case '2':
  368. ele_remover = criar_elemento();
  369. ler_elemento(ele_remover);
  370. ele_removido = remover_elemento(lista, ele_remover);
  371. if (ele_removido) {
  372. printf("O elemento foi removido!\n");
  373. mostrar_elemento(ele_removido);
  374. libertar_elemento(ele_removido);
  375. }else
  376. printf("Não foi encontrado nenhum elemento!\n");
  377. break;
  378. case '3':
  379. ele_removido = remover_ultimo(lista);
  380. if (ele_removido) {
  381. printf("Foi removido o ultimo elemento\n");
  382. mostrar_elemento(ele_removido);
  383. libertar_elemento(ele_removido);
  384. } else
  385. printf("Não foi encontrado nenhum elemento!\n");
  386. break;
  387. case '4':
  388. destruir(lista);
  389. break;
  390. }
  391. break;
  392. case '3':
  393. if (lista->nelementos == 0)
  394. printf("Nao existem elementos na lista!\n");
  395. else
  396. mostrar_ordenado(lista);
  397. break;
  398. case '4':
  399. if (lista->nelementos == 0)
  400. printf("Nao existem elementos na lista!\n");
  401. else
  402. mostrar_inversa(lista);
  403. break;
  404. case '5':
  405. printf("Numero de elementos da lista: %d\n", lista->nelementos);
  406. break;
  407. case '6':
  408. ele_pesquisar = criar_elemento();
  409. ler_elemento(ele_pesquisar);
  410. printf("Pesquisar iterativo\n");
  411. if (pesquisar_iterativo(lista, ele_pesquisar))
  412. printf("O elemento introduzido existe na lista!\n");
  413. else
  414. printf("O elemento introduzido nao existe na lista!\n");
  415. printf("Pesquisar recursivo\n");
  416. if (pesquisar_recursivo(lista, ele_pesquisar))
  417. printf("O elemento introduzido existe na lista!\n");
  418. else
  419. printf("O elemento introduzido nao existe na lista!\n");
  420. break;
  421. case '7':
  422. if (elementos_repetidos(lista))
  423. printf("Existem elementos repetidos na lista!\n");
  424. else
  425. printf("Nao existem elementos repetidos na lista!\n");
  426. break;
  427. case '8':
  428. exportar_ficheiro(lista, NOME_FICHEIRO);
  429. break;
  430. case '9':
  431. importar_ficheiro(lista, NOME_FICHEIRO);
  432. break;
  433. case '0':
  434. exit(0);
  435. }
  436. system("pause");
  437. }
  438. }
Add Comment
Please, Sign In to add comment