API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Apr 1st, 2020
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 35.52 KB | None | 0 0
raw download clone embed print report
  1. /* Programmatismos2
  2. ---project2.c : mia pio polyploki basi dedomenwn me dynamiki desmeusi mnimis.
  3. ---Onomatepwnymo : Sarafoglou Dimitrios
  4. ---AEM : 02993
  5. */
  6.  
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <ctype.h>
  11. #include <signal.h>
  12.  
  13. struct COURSE_CODE
  14. {
  15. short unsigned int code;
  16. struct COURSE_CODE *next;
  17. };
  18. typedef struct COURSE_CODE course_code;
  19.  
  20. struct ENTRY
  21. {
  22. long unsigned int AEM;
  23. short unsigned int courses;
  24. char name[64];
  25. struct ENTRY *next_student;
  26. struct ENTRY *previous_student;
  27. course_code *root;
  28. };
  29. typedef struct ENTRY entry;
  30.  
  31. typedef struct
  32. {
  33. entry **entries;
  34. entry **hash_table;
  35. int size;
  36. int hashTable_size;
  37. int capacity;
  38. int increaser;
  39. int decreaser;
  40. int isSorted;
  41. } entry_list;
  42.  
  43. /* Ylopoihsh synarthsewn. */
  44.  
  45. /* Initalization functions. */
  46. void init_entry_list(entry_list *el)
  47. {
  48. el->entries = NULL;
  49. el->capacity = 0;
  50. el->size = 0;
  51. el->increaser = 0;
  52. el->decreaser = 0;
  53. el->isSorted = 0;
  54. }
  55.  
  56. void init_course_list(entry_list *el)
  57. {
  58. int i;
  59. for (i=0; i<el->size; i++)
  60. el->entries[i]->root = NULL;
  61. }
  62.  
  63. void hash_table_init(entry_list *el)
  64. { /* Sti sinartisi auti xrisimopoioume kathe thesi tou hash_table ws ena root gia lista. */
  65.  
  66. int i;
  67. for (i=0; i<el->hashTable_size; i++)
  68. {
  69. el->hash_table[i] = (entry *) malloc(sizeof(entry)); /* Sentinel node. */
  70. if (el->hash_table[i] == NULL)
  71. exit(0); /* No memory for allocation. */
  72.  
  73. el->hash_table[i]->next_student = NULL;
  74. }
  75. }
  76.  
  77. void hash_table_init2(entry_list *el)
  78. {
  79. int i;
  80. for (i=0; i<el->hashTable_size; i++)
  81. {
  82. el->hash_table[i] = (entry *) malloc(sizeof(entry));
  83. if (el->hash_table[i] == NULL)
  84. exit(0); /* No memory for allocation. */
  85.  
  86. el->hash_table[i]->previous_student = el->hash_table[i];
  87. el->hash_table[i]->next_student = el->hash_table[i];
  88. }
  89. }
  90.  
  91. void clear_hash_table(entry_list *el)
  92. {
  93. int i;
  94. for (i=0; i<el->hashTable_size; i++)
  95. free(el->hash_table[i]);
  96. free(el->hash_table);
  97. }
  98.  
  99. long unsigned int hash(char *str)
  100. {
  101. long unsigned int hash = 5381;
  102. int c;
  103.  
  104. while ((c = *str++))
  105. hash = ((hash << 5) + hash) + c;
  106.  
  107. return hash;
  108. }
  109.  
  110.  
  111. /* Binary search or linear search (in one). */
  112. int student_search(entry_list *el, long unsigned int AEM)
  113. {
  114. int i, middle, from = 0, to = el->size-1;
  115.  
  116. if (el->isSorted == 0)
  117. {
  118. /* Edw ta AEM den einai taksinomimena, ara efarmozoume linear search. */
  119. for (i=0; i<el->size; i++)
  120. {
  121. if (AEM == el->entries[i]->AEM)
  122. {
  123. return 1;
  124. }
  125. }
  126. return 0;
  127. }
  128. else
  129. {
  130. /* Edw o pinakas me ta AEM einai taksinomimenos, opote efarmozoume binary search. */
  131. while(from <= to)
  132. {
  133. middle = (to + from) / 2;
  134. if (el->entries[middle]->AEM == AEM)
  135. {
  136. return 1;
  137. }
  138. else if (el->entries[middle]->AEM > AEM)
  139. {
  140. to = middle - 1;
  141. }
  142. else
  143. {
  144. from = middle + 1;
  145. }
  146. }
  147. return 0;
  148. }
  149. }
  150.  
  151. int find_cmps(entry_list *el, long unsigned int AEM)
  152. {
  153. int i, middle, from = 0, to = el->size-1, comparisons = 0;
  154. if (el->isSorted == 0)
  155. {
  156. for (i=0; i<el->size; i++)
  157. {
  158. if (AEM == el->entries[i]->AEM)
  159. {
  160. comparisons++;
  161. break;
  162. }
  163. else
  164. {
  165. comparisons++;
  166. continue;
  167. }
  168. }
  169. return comparisons;
  170. }
  171. else
  172. {
  173. while (from <= to)
  174. {
  175. middle = (to + from) / 2;
  176. if (el->entries[middle]->AEM == AEM)
  177. {
  178. comparisons++;
  179. return comparisons;
  180. }
  181. comparisons++;
  182. if (el->entries[middle]->AEM > AEM)
  183. {
  184. comparisons++;
  185. to = middle - 1;
  186. }
  187. else
  188. {
  189. comparisons++;
  190. from = middle + 1;
  191. }
  192. }
  193. return comparisons;
  194. }
  195. }
  196.  
  197.  
  198. /* Find comparisons while sorting function.
  199. H synartisi epistrefei to plithos twn sygkrisewn. */
  200. int insertion_sort(entry_list *el, long unsigned int AEM)
  201. {
  202. int i, step, key_aem, key_course, comparisons = 0;
  203. char key_name[64] = {'\0'};
  204. for (step = 1; step < el->size; step++) /* step = 1: afinoume to prwto stoixeio, giati theoroume oti einai sorted. */
  205. {
  206. i = step - 1;
  207. key_aem = el->entries[step]->AEM;
  208. key_course = el->entries[step]->courses;
  209. strcpy(key_name, el->entries[step]->name);
  210.  
  211. comparisons++;
  212.  
  213. while(i>=0 && key_aem < el->entries[i]->AEM)
  214. {
  215. if (i == 0)
  216. {
  217. comparisons--;
  218. }
  219. comparisons++;
  220. el->entries[i+1]->AEM = el->entries[i]->AEM;
  221. el->entries[i+1]->courses = el->entries[i]->courses;
  222. strcpy(el->entries[i+1]->name, el->entries[i]->name);
  223. i--;
  224.  
  225. if (i < 0)
  226. {
  227. break;
  228. }
  229. }
  230. el->entries[i+1]->AEM = key_aem;
  231. el->entries[i+1]->courses = key_course;
  232. strcpy(el->entries[i+1]->name, key_name);
  233. }
  234.  
  235. el->isSorted = 1; /* Sorted. */
  236.  
  237. return comparisons;
  238. }
  239.  
  240. /* Swap. */
  241. void swap(course_code *a, course_code *b)
  242. {
  243. int temp;
  244. temp = a->code;
  245. a->code = b->code;
  246. b->code = temp;
  247. }
  248.  
  249. /* Sorting of nodes(codes of courses). */
  250. void course_sorting(course_code *root)
  251. {
  252. int cont;
  253. course_code *ptr1, *ptr2 = NULL;
  254.  
  255. /* Tsekaroume an i lista mas einai keni. */
  256. if (root == NULL)
  257. return;
  258.  
  259. do
  260. {
  261. cont = 0;
  262. ptr1 = root;
  263.  
  264. while (ptr1->next != ptr2)
  265. {
  266. if (ptr1->code > ptr1->next->code)
  267. {
  268. swap(ptr1,ptr1->next);
  269. cont = 1;
  270. }
  271. ptr1 = ptr1->next;
  272. }
  273. ptr2 = ptr1;
  274. } while(cont);
  275. }
  276.  
  277.  
  278.  
  279. /* Find position of student function
  280. H synartisi epistrefei tin thesi tou foititi mesa stin agenta.
  281. */
  282. int find_pos_of_student(entry_list *el, long unsigned int AEM)
  283. {
  284. int position;
  285. for (position = 0; (position < el->capacity) && (el->entries[position] != NULL); position++)
  286. {
  287. if (el->entries[position]->AEM == AEM)
  288. {
  289. break;
  290. }
  291. }
  292. return position;
  293. }
  294.  
  295. /* Hash Table's content is printed. */
  296. void print_hash_table(entry_list *el)
  297. {
  298. entry *current;
  299. course_code *current_course;
  300.  
  301. int i;
  302. for (i=0; i<el->hashTable_size; i++)
  303. {
  304. if (el->hash_table[i]->next_student == el->hash_table[i]) /* Periptwsi opou exoume keno bucket. */
  305. continue;
  306. for (current=el->hash_table[i]->next_student; current!=el->hash_table[i]; current=current->next_student)
  307. {
  308. printf("----------------------------\n");
  309. printf("[Position in the Hash Table]: %d\n", i);
  310. printf("[Name]: %s\n", current->name);
  311. printf("[AEM]: %lu\n", current->AEM);
  312. printf("[Courses]: %hu\n", current->courses);
  313. printf("%s is registered in these courses:\n", current->name);
  314. for (current_course=current->root; current_course!=NULL; current_course=current_course->next)
  315. {
  316. printf("%hu\n", current_course->code);
  317. }
  318. }
  319. }
  320. }
  321.  
  322. /* Find student in a circular list function.
  323. 1: If YES
  324. 0: If NO
  325. */
  326. int student_search_circular_list(entry_list *el, long unsigned int AEM, char name[])
  327. {
  328. entry *current;
  329. int position_in_HT = hash(name) % (el->hashTable_size);
  330.  
  331. el->hash_table[position_in_HT]->AEM = AEM;
  332. for (current=el->hash_table[position_in_HT]->next_student; current!=el->hash_table[position_in_HT]; current=current->next_student)
  333. {
  334. if (current->AEM == AEM)
  335. return 1; /* O foititis yparxei idi sto hash table. */
  336. }
  337. return 0;
  338. }
  339.  
  340.  
  341. /* Insert name to hash table function.
  342. Return 0: An o foititis iparxei idi sti lista.
  343. Return -1: An o foititis den yparxei sto database.
  344. Return 1: Success.
  345. */
  346. void entry_insert_to_HTable2(entry_list *el, long unsigned int AEM, char name[])
  347. {
  348. int i;
  349. entry *current;
  350. float load_factor = el->size / el->hashTable_size;
  351.  
  352. int position_in_HT = hash(name) % (el->hashTable_size); /* Thesi ston pinaka hash. */
  353. int position = find_pos_of_student(el, AEM); /* Thesi ston pinaka twn entries. */
  354.  
  355. /* Periptwsi opou i lista mas einai keni. */
  356. if (el->hash_table[position_in_HT]->next_student == el->hash_table[position_in_HT])
  357. {
  358. el->hash_table[position_in_HT]->next_student = el->entries[position];
  359. el->entries[position]->previous_student = el->hash_table[position_in_HT];
  360. el->entries[position]->next_student = el->hash_table[position_in_HT];
  361. }
  362. else /* Periptwsi opou i lista den einai keni. */
  363. {
  364. /* Mesa edw kanw to sorting.
  365. Den pairnw periptwsi otan exw keni lista , giati den ginetai kapoiou eidous sortarisma. */
  366. for (current=el->hash_table[position_in_HT]->next_student; current!=el->hash_table[position_in_HT]; current=current->next_student)
  367. {
  368. if (strcmp(name, current->name) < 0)
  369. break;
  370. }
  371. /* Periptwsi opou i eggrafi mpainei stin arxi h se endiameso simeio tis listas tou bucket se sygkekrimeni thesi tou hash table. */
  372. if (current != el->hash_table[position_in_HT])
  373. {
  374. el->entries[position]->next_student = current;
  375. el->entries[position]->previous_student = current->previous_student;
  376. current->previous_student = el->entries[position];
  377. el->entries[position]->previous_student->next_student = el->entries[position];
  378. }
  379. else
  380. {
  381. /* Periptwsi opou prepei i eggrafi na mpei sto telos tis listas. */
  382. for (current=el->hash_table[position_in_HT]->next_student; current->next_student!=el->hash_table[position_in_HT]; current=current->next_student);
  383.  
  384. el->entries[position]->previous_student = current;
  385. el->entries[position]->next_student = current->next_student;
  386. current->next_student = el->entries[position];
  387. }
  388.  
  389.  
  390. /*el->entries[position]->next_student = el->hash_table[position_in_HT]->next_student;
  391. el->hash_table[position_in_HT]->next_student = el->entries[position];
  392. el->entries[position]->next_student->previous_student = el->hash_table[position_in_HT]->next_student;
  393. el->entries[position]->previous_student = el->hash_table[position_in_HT];
  394. */
  395. }
  396.  
  397. if (load_factor >= 4)
  398. {
  399. /* Periptwsi opou prepei na kanoume rehashing. */
  400. /* Apodeseusi tou trexonta hash table. */
  401. clear_hash_table(el);
  402.  
  403. entry **temp;
  404. temp = (entry **) malloc(sizeof(entry *) * 2 * el->hashTable_size);
  405. if (temp == NULL)
  406. exit(0); /* No memory for allocation. */
  407.  
  408. el->hashTable_size *= 2;
  409. el->hash_table = temp;
  410.  
  411. hash_table_init2(el);
  412. for (i=0; i<el->size; i++)
  413. {
  414. position_in_HT = hash(el->entries[i]->name) % el->hashTable_size;
  415. if (el->hash_table[position_in_HT]->next_student == el->hash_table[position_in_HT])
  416. {
  417. el->hash_table[position_in_HT]->next_student = el->entries[i];
  418. el->entries[i]->next_student = el->hash_table[position_in_HT];
  419. el->entries[i]->previous_student = el->hash_table[position_in_HT];
  420. }
  421. else
  422. {
  423. el->entries[i]->next_student = el->hash_table[position_in_HT]->next_student;
  424. el->hash_table[position_in_HT]->next_student = el->entries[i];
  425. el->entries[i]->previous_student = el->hash_table[position_in_HT];
  426. el->entries[i]->next_student->previous_student = el->hash_table[position_in_HT]->next_student;
  427. }
  428. }
  429. }
  430. }
  431.  
  432. void entry_remove_from_HT2(entry_list *el, long unsigned int AEM, char name[], int StartingHT_size)
  433. {
  434. float load_factor = el->size / el->hashTable_size;
  435. entry *current, **temp;
  436.  
  437. int position_in_HT = hash(name) % el->hashTable_size;
  438.  
  439. el->hash_table[position_in_HT]->AEM = AEM;
  440. for (current=el->hash_table[position_in_HT]->next_student; current->AEM!=AEM; current=current->next_student);
  441.  
  442. if (current != el->hash_table[position_in_HT])
  443. {
  444. /* Parakampsi komvou. */
  445. if (current->next_student == el->hash_table[position_in_HT])
  446. {
  447. current->previous_student->next_student = current->next_student;
  448. current->next_student = NULL;
  449. current->previous_student = NULL;
  450. }
  451. current->next_student->previous_student = current->previous_student;
  452. current->previous_student->next_student = current->next_student;
  453.  
  454. current->previous_student = NULL;
  455. current->next_student = NULL;
  456. }
  457.  
  458. if (load_factor == 1)
  459. {
  460. /* Edw vriskoume to neo (meiomeno) megethos gia to hash table. */
  461. if ((el->hashTable_size / 2) < StartingHT_size)
  462. el->hashTable_size = StartingHT_size;
  463. else
  464. el->hashTable_size = el->hashTable_size / 2;
  465.  
  466. clear_hash_table(el);
  467.  
  468. temp = (entry **) malloc(sizeof(entry *) * el->hashTable_size);
  469. if (temp == NULL)
  470. exit(0); /* No memory for allocation. */
  471.  
  472. el->hash_table = temp;
  473. hash_table_init2(el);
  474.  
  475. int position = find_pos_of_student(el, AEM);
  476.  
  477. /* Twra kanoume rehashing. */
  478. int i;
  479. for (i=0; i<el->size; i++)
  480. {
  481. if (i == position)
  482. continue;
  483.  
  484. position_in_HT = hash(el->entries[i]->name) % el->hashTable_size;
  485. if (el->hash_table[position_in_HT]->next_student == el->hash_table[position_in_HT])
  486. {
  487. el->hash_table[position_in_HT]->next_student = el->entries[i];
  488. el->entries[i]->next_student = el->hash_table[position_in_HT];
  489. el->entries[i]->previous_student = el->hash_table[position_in_HT];
  490. }
  491. else
  492. {
  493. el->entries[i]->next_student = el->hash_table[position_in_HT]->next_student;
  494. el->hash_table[position_in_HT]->next_student = el->entries[i];
  495. el->entries[i]->previous_student = el->hash_table[position_in_HT];
  496. el->entries[i]->next_student->previous_student = el->hash_table[position_in_HT]->next_student;
  497. }
  498. }
  499. }
  500. }
  501.  
  502.  
  503.  
  504. void sort_circ_list(entry_list *el, char name[])
  505. {
  506. entry *current, *index;
  507.  
  508. long unsigned int temp_AEM;
  509. short unsigned int temp_courses;
  510. char temp_name[64];
  511. course_code *temp_root;
  512.  
  513. /* Prepei na vroume ti thesi sto hash table tis listas tin opoia theloume na sortaroume. */
  514. int position_in_HT = hash(name) % el->hashTable_size;
  515.  
  516. current = el->hash_table[position_in_HT]->next_student;
  517.  
  518. do {
  519. index = current->next_student;
  520. while(index != el->hash_table[position_in_HT]->next_student)
  521. {
  522. if (strcmp(current->name, index->name) > 0)
  523. {
  524. /* Edw tha ginei to swapping metaksy twn entries. */
  525. temp_AEM = current->AEM;
  526. current->AEM = index->AEM;
  527. index->AEM = temp_AEM;
  528.  
  529. temp_courses = current->courses;
  530. current->courses = index->courses;
  531. index->courses = temp_courses;
  532.  
  533. strcpy(temp_name, current->name);
  534. strcpy(current->name, index->name);
  535. strcpy(index->name, temp_name);
  536.  
  537. temp_root = current->root;
  538. current->root = index->root;
  539. index->root = temp_root;
  540. }
  541. else if (strcmp(current->name, index->name) == 0)
  542. {
  543. /* Edw sortaroume me basi to AEM. */
  544. if (current->AEM > index->AEM)
  545. {
  546. temp_AEM = current->AEM;
  547. current->AEM = index->AEM;
  548. index->AEM = temp_AEM;
  549.  
  550. temp_courses = current->courses;
  551. current->courses = index->courses;
  552. index->courses = temp_courses;
  553.  
  554. temp_root = current->root;
  555. current->root = index->root;
  556. index->root = temp_root;
  557.  
  558. /* Ta onomata den xreiazontai swapping, giati einia idia. */
  559. }
  560. }
  561. index = index->next_student;
  562. }
  563. current = current->next_student;
  564.  
  565. } while(current->next_student != el->hash_table[position_in_HT]->next_student);
  566. }
  567.  
  568.  
  569. /* Add student function.
  570. H synartisi auti epistrefei 1: An o foititis prostethike epityxws.
  571. H synartisi auti epistrefei 0: An o foititis yparxei idi.
  572. */
  573. int add(entry_list *el, long unsigned int AEM, short unsigned int courses, char name[])
  574. {
  575. entry **temp;
  576. int i, length;
  577. int finder;
  578.  
  579. finder = student_search(el, AEM);
  580. if (finder == 1)
  581. {
  582. /* Simainei oti o foititis yparxei idi. */
  583. return 0;
  584. }
  585. else
  586. {
  587. /* Prwta eksetazoume tin periptwsi opou den yparxei xwros ston pinaka deiktwn. */
  588. if (el->capacity == el->size)
  589. {
  590. temp = (entry **) realloc(el->entries, (el->capacity + el->increaser) * sizeof(entry *));
  591. if (temp == NULL)
  592. {
  593. /* No memory for allocation!\n */
  594. exit(0);
  595. }
  596.  
  597. /* Desmeuoume xwro gia tin yparksi neas eggrafis. */
  598. entry *student;
  599. student = (entry *) malloc(sizeof(entry));
  600. if (student == NULL)
  601. {
  602. /* No memory for allocation... */
  603. exit(0);
  604. }
  605.  
  606. el->entries = temp;
  607. /* for (i=el->capacity; i<(el->capacity+el->increaser); i++)
  608. {
  609. el->entries[i]->root = NULL;
  610. }*/
  611. el->capacity += el->increaser;
  612. el->entries[el->size] = student;
  613. el->entries[el->size]->AEM = AEM;
  614. el->entries[el->size]->courses = courses;
  615.  
  616. /* Metatropi tou onomatos se kefalaia. */
  617. length = strlen(name);
  618. for (i=0; i<length; i++)
  619. {
  620. name[i] = toupper(name[i]);
  621. }
  622. strcpy(el->entries[el->size]->name, name);
  623. el->entries[el->size]->root = NULL;
  624. //el->entries[el->size]->next_student = NULL;
  625.  
  626. el->size++;
  627. el->isSorted = 0;
  628.  
  629. entry_insert_to_HTable2(el, AEM, name);
  630. //sort_circ_list(el, name);
  631. return 1;
  632. }
  633. /* Twra eksetazoume tin periptwsi opou yparxei eleutheros xwros ston pinaka deiktwn. */
  634.  
  635. /* Desmeuw xwro gia mia nea eggrafi. */
  636. entry *student;
  637. student = (entry *) malloc(sizeof(entry));
  638. if (student == NULL)
  639. {
  640. /* No memory for allocation... */
  641. exit(0);
  642. }
  643.  
  644. el->entries[el->size] = student;
  645. el->entries[el->size]->AEM = AEM;
  646. el->entries[el->size]->courses = courses;
  647. el->entries[el->size]->root = NULL;
  648. el->entries[el->size]->next_student = NULL;
  649.  
  650. /* Metatropi tou onomatos se kefalaia. */
  651. length = strlen(name);
  652. for (i=0; i<length; i++)
  653. {
  654. name[i] = toupper(name[i]);
  655. }
  656. strcpy(el->entries[el->size]->name, name);
  657.  
  658. el->size++;
  659. el->isSorted = 0;
  660.  
  661. entry_insert_to_HTable2(el, AEM, name);
  662. //sort_circ_list(el, name);
  663. return 1;
  664. }
  665. }
  666.  
  667. /* Find course function.
  668. H synartisi epistrefei 1: an to mathima vrethike.
  669. H synartisi epistrefei 0: an to mathima den vrethike. */
  670. int find_course(entry_list *el, short unsigned int code, long unsigned int AEM)
  671. {
  672. course_code *current;
  673.  
  674. if (student_search(el, AEM) == 0) /* Pou Simainei oti o foititis den vrethike. */
  675. return 0; /* Oute kai to mathima tha yparxei epomenws. */
  676.  
  677. /* An o foititis yparxei, prepei na vroume ti thesi tou. */
  678. int position = find_pos_of_student(el, AEM);
  679. for (current=el->entries[position]->root; current!=NULL; current=current->next)
  680. {
  681. if (current->code == code)
  682. return 1;
  683. }
  684. return 0;
  685. }
  686.  
  687.  
  688. /* isreg function.
  689. Epistrefetai: 1 an einai eggegrammenos.
  690. 0 an den yparxei sto database.
  691. -1 an den einai eggegrammenos.*/
  692. int isRegistered(entry_list *el, short unsigned int code, long unsigned int AEM)
  693. {
  694. int finder = student_search(el, AEM);
  695. if (finder == 0)
  696. return -1;
  697.  
  698. int position = find_pos_of_student(el, AEM);
  699.  
  700. course_code *current;
  701. for (current=el->entries[position]->root; current!=NULL; current=current->next)
  702. {
  703. if (current->code == code)
  704. return 1;
  705. }
  706. return 0;
  707. }
  708.  
  709.  
  710. /* Insert course node to the list function (Eggrafi foititi se mathima).
  711. H synartisi auti epistrefei 1 an i eisagwgi tou node stin lista egine me epityxia,
  712. alliws 0 se periptwsi pou o mathitis den vrisketai sto database kai -1 se periptwsi
  713. pou einai idi eggegrammenos. */
  714. int course_insert(entry_list *el, short unsigned int code, long unsigned int AEM)
  715. {
  716. int finder = student_search(el, AEM);
  717. if (finder == 0) /* Den yparxei o mathitis. */
  718. return 0; /* Den mporw na prosthesw mathima. */
  719.  
  720. int find_crs = find_course(el, code, AEM);
  721. if (find_crs == 1) /* O mathitis einai eggegrammenos. */
  722. return -1;
  723.  
  724. int position = find_pos_of_student(el, AEM);
  725.  
  726. course_code *current;
  727. current = (course_code *) malloc(sizeof(course_code));
  728. if (current == NULL)
  729. exit(0); /* No memory for allocation. */
  730.  
  731. current->code = code;
  732. current->next = el->entries[position]->root;
  733. el->entries[position]->root = current;
  734.  
  735. /* Twra sortaroume. */
  736. course_sorting(el->entries[position]->root);
  737.  
  738. return 1; /* inserted. */
  739.  
  740. }
  741.  
  742. /* Remove course function.
  743. H synartisi auti epistrefei 1: an petyxe h apomakrynsi komvou.
  744. H synartisi auti epistrefei 0: an o foititis den yparxe sto database.
  745. H synartisi auti epistrefei -1: an to mathima pou theloume na afairesoume den yparxei.*/
  746. int remove_course(entry_list *el, short unsigned int code, long unsigned int AEM)
  747. {
  748. int finder = student_search(el, AEM);
  749. if (finder == 0) /* O foititis den yparxei sto database. */
  750. return 0;
  751.  
  752. course_code *current, *previous;
  753. int position = find_pos_of_student(el, AEM);
  754. for (current=el->entries[position]->root; current!=NULL; previous=current,current=current->next)
  755. {
  756. if (current->code == code)
  757. break;
  758. }
  759. if (current != NULL)
  760. {
  761. if (current == el->entries[position]->root)
  762. el->entries[position]->root = current->next;
  763. else
  764. previous->next = current->next;
  765. }
  766. else
  767. {
  768. return -1;
  769. }
  770. free(current);
  771. return 1; /* removed. */
  772. }
  773.  
  774.  
  775.  
  776. /* Remove student function
  777. H synartisi auti epistrefei 1: an o foititis afairethike me epityxia.
  778. H synartisi auti epistrefei 0: an to AEM to foititi den yparxei sti lista h an exw kenh lista me entries h an h apodeseusi tou pinaka apetyxe.
  779. */
  780. int remove_student(entry_list *el, long unsigned int AEM, int StartingHT_size)
  781. {
  782. int finder, position, i, empty_positions = 0;
  783. entry **temp;
  784.  
  785. if (el->size == 0)
  786. {
  787. /* Periptwsi opou den exw kanena entry, opote den mporw na afairesw tpt. */
  788. return 0;
  789. }
  790.  
  791. /* Periptwsi opou den yparxei o mathitis, ara den mporw na ton afairesw. */
  792. finder = student_search(el, AEM);
  793. if (finder == 0)
  794. {
  795. return 0; /* O foititis den vrethike. */
  796. }
  797.  
  798. /* Periptwsi opou o mathitis yparxei, kai thelw na ton afairesw. */
  799. position = find_pos_of_student(el, AEM);
  800.  
  801. entry_remove_from_HT2(el, AEM, el->entries[position]->name, StartingHT_size);
  802.  
  803. if (position == el->size-1)
  804. {
  805. /* Simainei oti h eggrafi vrisketai stin teleutaia thesi tis listas eggrafwn. */
  806. /* Prwta prepei na kanoume apodesmeusi tous komvous. */
  807. /* Kai meta apodesmeusi tou struct tou foititi. */
  808. course_code *current;
  809. while (el->entries[position]->root != NULL)
  810. {
  811. current = el->entries[position]->root;
  812. el->entries[position]->root = el->entries[position]->root->next;
  813. free(current);
  814. }
  815. // Me to pou vgw apo tin loopa: el->entries[position]->root = NULL.
  816.  
  817. free(el->entries[position]);
  818.  
  819. el->entries[position] = NULL;
  820. el->size--;
  821.  
  822. /* Vriskoume poses kenes (NULL) theseis exei o pinakas deiktwn. */
  823. for (i=0; i<el->capacity; i++)
  824. {
  825. if (el->entries[i] != NULL)
  826. continue;
  827.  
  828. else
  829. empty_positions++;
  830. }
  831.  
  832. if (empty_positions > el->decreaser)
  833. {
  834. temp = (entry **) realloc(el->entries, (el->capacity - el->decreaser) * sizeof(entry));
  835. if (temp == NULL)
  836. {
  837. /* realloc() failed... */
  838. exit(0);
  839. }
  840. el->entries = temp;
  841. el->capacity -= el->decreaser;
  842. }
  843.  
  844. return 1; /* removed */
  845. }
  846. else
  847. {
  848. /* Periptwsi opou o foititis den vrisketai stin teleutaia thesi. */
  849. /* Prepei na apodesmeusoume tous komvous gia ta mathimata. */
  850. course_code *current;
  851. while (el->entries[position]->root != NULL)
  852. {
  853. current = el->entries[position]->root;
  854. el->entries[position]->root = el->entries[position]->root->next;
  855. free(current);
  856. }
  857.  
  858. free(el->entries[position]);
  859. el->entries[position] = el->entries[el->size-1];
  860. el->entries[el->size-1] = NULL;
  861. el->size--;
  862.  
  863. /* Vriskoume poses kenes (NULL) theseis exei o pinakas deiktwn. */
  864. for (i=0; i<el->capacity; i++)
  865. {
  866. if (el->entries[i] != NULL)
  867. continue;
  868. else
  869. empty_positions++;
  870. }
  871.  
  872. if (empty_positions > el->decreaser)
  873. {
  874. temp = (entry **) realloc(el->entries, (el->capacity - el->decreaser) * sizeof(entry));
  875. if (temp == NULL)
  876. {
  877. /* realloc() failed... */
  878. exit(0);
  879. }
  880. el->entries = temp;
  881. el->capacity -= el->decreaser;
  882.  
  883. }
  884. el->isSorted = 0;
  885. return 1; /* removed */
  886.  
  887. }
  888.  
  889. }
  890.  
  891. /* Find by name function. */
  892. void find_by_name(entry_list *el, char name[])
  893. {
  894.  
  895. }
  896.  
  897.  
  898. /* Modify courses based on AEM function.
  899. H synartisi epistrefei 1: an epiteuxthei h tropopoiisi.
  900. H synartisi epistrefei 0: an h tropoiisi den epiteuxthei h an o foititis gia ton opoio theloume na kanoume tis allages den yparxei sti lista mas. */
  901. int course_modify(entry_list *el, const long unsigned int AEM, short unsigned int courses)
  902. {
  903. int finder, position;
  904. finder = student_search(el, AEM);
  905.  
  906. if (finder == 0)
  907. {
  908. /* Simainei oti o foititis den yparxei sti lista. */
  909. return 0;
  910. }
  911.  
  912. /* O foititis yparxei sti lista. Prepei na vrethei i thesi tou. */
  913. position = find_pos_of_student(el, AEM);
  914. el->entries[position]->courses = courses;
  915.  
  916. return 1; /* changed. */
  917. }
  918.  
  919. /* List courses function. */
  920. void list_courses(entry_list *el, short unsigned int code, long unsigned int AEM)
  921. {
  922. int position = find_pos_of_student(el, AEM);
  923.  
  924. course_code *current;
  925.  
  926. printf("\nL-OK %s\n", el->entries[position]->name);
  927. for (current=el->entries[position]->root; current!=NULL; current=current->next)
  928. printf("%d\n", current->code);
  929. }
  930.  
  931. /* Print entries function.
  932. H synartisi epistrefei void. */
  933. void print_entries(entry_list *el)
  934. {
  935. int i;
  936.  
  937. printf("\n#\n");
  938.  
  939. for (i=0; i<el->size; i++)
  940. printf("%lu %s %hu\n", el->entries[i]->AEM, el->entries[i]->name, el->entries[i]->courses);
  941. }
  942.  
  943. /* Clear function. */
  944. void clear_entries(entry_list *el)
  945. {
  946. int i;
  947. entry *freePointer;
  948. course_code *current;
  949.  
  950. /* Arxika prepei na diagrapsoume oles tis eggrafes. */
  951. for (i=0; i<el->size; i++)
  952. {
  953. /* Arxika prepei na diagrapsoume ti lista tou kathe foititi. */
  954. while (el->entries[i]->root != NULL)
  955. {
  956. current = el->entries[i]->root;
  957. el->entries[i]->root = el->entries[i]->root->next;
  958. free(current);
  959. }
  960. freePointer = el->entries[i];
  961. free(freePointer);
  962. }
  963.  
  964. for (i=0; i<el->capacity; i++)
  965. {
  966. free(el->entries[i]);
  967. }
  968. free(el->entries);
  969. el->size = 0;
  970. el->capacity = 0;
  971. el->entries = NULL;
  972. el->isSorted = 0;
  973. }
  974.  
  975. /* Main. */
  976. int main(int argc, char **argv)
  977. {
  978. long unsigned int AEM = 0;
  979. short unsigned int courses = 0, code;
  980. char name[64] = {'\0'}, menu_choice;
  981. int add_tester, remove_tester, mod_tester, find_tester, position, comparisons = 0, sorting_comparisons = 0;
  982. int reg_tester, unreg_tester, isReg_tester;
  983.  
  984. if (argc != 4)
  985. {
  986. printf("Invalid command-line arguments!\n");
  987. return 0;
  988. }
  989.  
  990. entry_list el;
  991.  
  992. //init_entry_list(&el);
  993. //init_course_list(&el);
  994.  
  995. el.capacity = atoi(argv[1]);
  996. el.entries = (entry **) malloc(sizeof(entry *) * el.capacity); /* Desmeusame xwro gia ton pinaka deiktwn dynamika. */
  997. if (el.entries == NULL)
  998. exit(0); /* No memory for allocation. */
  999.  
  1000. init_entry_list(&el);
  1001. init_course_list(&el);
  1002.  
  1003. el.decreaser = atoi(argv[2]);
  1004. el.increaser = atoi(argv[2]);
  1005.  
  1006. el.hashTable_size = atoi(argv[3]);
  1007. el.hash_table = (entry **) malloc(sizeof(entry *) * el.hashTable_size); /* Desmeuoume xwro gia to hash table. */
  1008. if (el.hash_table == NULL)
  1009. exit(0); /* No memory for allocation. */
  1010.  
  1011. hash_table_init2(&el);
  1012.  
  1013. while(1)
  1014. {
  1015. scanf(" %c", &menu_choice);
  1016. switch(menu_choice)
  1017. {
  1018. case 'a':
  1019. {
  1020. scanf("%lu %63s %hu", &AEM, name, &courses);
  1021. add_tester = add(&el, AEM, courses, name);
  1022. if (add_tester == 0)
  1023. {
  1024. /* Simainei oti den petyxe h eggrafi. */
  1025. printf("\nA-NOK %lu, %d %d\n", AEM, el.size, el.capacity);
  1026. }
  1027. else
  1028. {
  1029. printf("\nA-OK %lu, %d %d\n", AEM, el.size, el.capacity);
  1030. }
  1031. break;
  1032. }
  1033. case 'g':
  1034. {
  1035. scanf("%lu %hu", &AEM, &code);
  1036.  
  1037. reg_tester = course_insert(&el, code, AEM);
  1038. if (reg_tester == 1)
  1039. printf("\nG-OK %lu %hu\n", AEM, code);
  1040.  
  1041. else if (reg_tester == 0)
  1042. printf("\nG-NOK %lu\n", AEM);
  1043. else
  1044. printf("\nG-NOK %hu\n", code);
  1045.  
  1046. break;
  1047. }
  1048. case 'r':
  1049. {
  1050. scanf("%lu", &AEM);
  1051. remove_tester = remove_student(&el, AEM, el.hashTable_size);
  1052. if (remove_tester == 1)
  1053. {
  1054. printf("\nR-OK %lu, %d %d\n", AEM, el.size, el.capacity);
  1055. }
  1056. else
  1057. {
  1058. printf("\nR-NOK %lu, %d %d\n", AEM, el.size, el.capacity);
  1059. }
  1060. break;
  1061. }
  1062. case 'u':
  1063. {
  1064. scanf("%lu %hu", &AEM, &code);
  1065. unreg_tester = remove_course(&el, code, AEM);
  1066. if (unreg_tester == 1)
  1067. printf("\nU-OK %lu %hu\n", AEM, code);
  1068.  
  1069. else if (unreg_tester == 0)
  1070. printf("\nU-NOK %lu\n", AEM);
  1071. else
  1072. printf("\nU-NOK %hu\n", code);
  1073. break;
  1074. }
  1075. case 's':
  1076. {
  1077.  
  1078. sorting_comparisons = insertion_sort(&el, AEM);
  1079. printf("\nS-OK\n");
  1080. fprintf(stderr, "\n$%d\n", sorting_comparisons);
  1081.  
  1082. break;
  1083. }
  1084. case 'i':
  1085. {
  1086. scanf("%lu %hu", &AEM, &code);
  1087. isReg_tester = isRegistered(&el, code, AEM);
  1088. if (isReg_tester == 1)
  1089. {
  1090. printf("\nYES\n");
  1091. }
  1092. else if (isReg_tester == 0)
  1093. {
  1094. printf("\nNO\n");
  1095. }
  1096. else
  1097. {
  1098. printf("\nI-NOK %lu\n", AEM);
  1099. }
  1100. break;
  1101. }
  1102. case 'f':
  1103. {
  1104. scanf("%lu", &AEM);
  1105. find_tester = student_search(&el, AEM);
  1106.  
  1107. if (find_tester == 1)
  1108. { position = find_pos_of_student(&el, AEM);
  1109. printf("\nF-OK %s %hu\n", el.entries[position]->name, el.entries[position]->courses);
  1110.  
  1111. comparisons = find_cmps(&el, AEM);
  1112. fprintf(stderr, "\n$%d\n", comparisons);
  1113. }
  1114. else
  1115. {
  1116. printf("\nF-NOK %lu\n", AEM);
  1117.  
  1118. comparisons = find_cmps(&el, AEM);
  1119. fprintf(stderr, "\n$%d\n", comparisons);
  1120. }
  1121. break;
  1122. }
  1123. case 'n':
  1124. {
  1125. scanf("%63s", name);
  1126. find_by_name(&el, name);
  1127. break;
  1128. }
  1129. case 'm':
  1130. {
  1131. scanf("%lu %hu", &AEM, &courses);
  1132. mod_tester = course_modify(&el, AEM, courses);
  1133.  
  1134. if (mod_tester == 1)
  1135. {
  1136. printf("\nM-OK %lu\n", AEM);
  1137. }
  1138. else
  1139. {
  1140. printf("\nM-NOK %lu\n", AEM);
  1141. }
  1142. break;
  1143. }
  1144. case 'p':
  1145. {
  1146. print_entries(&el);
  1147. break;
  1148. }
  1149. case 'h':
  1150. {
  1151. print_hash_table(&el);
  1152. break;
  1153. }
  1154. case 'l':
  1155. {
  1156. scanf("%lu", &AEM);
  1157.  
  1158. find_tester = student_search(&el, AEM);
  1159. if (find_tester == 0) /* O foititis den yparxei sto database. */
  1160. printf("\nL-NOK %lu\n", AEM);
  1161. else
  1162. {
  1163. list_courses(&el, code, AEM);
  1164. }
  1165. break;
  1166. }
  1167. case 'c':
  1168. {
  1169. clear_entries(&el);
  1170. clear_hash_table(&el);
  1171. hash_table_init(&el);
  1172. printf("\nC-OK\n");
  1173. break;
  1174. }
  1175. case 'q':
  1176. return 0;
  1177. }
  1178. }
  1179.  
  1180. return 0;
  1181. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!