SHARE
TWEET

Untitled

a guest Feb 27th, 2020 82 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /* Modul 0, No.1
  2. * Linked List -> fungsi untuk setiap element int Linked List
  3. * MENYIMPAN INT
  4. * Double pointer = pointer to pointer
  5. *   utk ganti head --> hrs di pass dari main
  6. */
  7.  
  8. #include <stdio.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <time.h>
  12. #include <stdbool.h>
  13.  
  14. typedef struct node
  15. {
  16.     int x;
  17.     struct node *next;
  18. } node;
  19.  
  20. unsigned int size = 0;
  21.  
  22. void pushFront(node **head, int num); // Masukin angka di head
  23. void pushBack(node *head, int num); // Masukin angka di tail
  24. void insertAt(node **head, int index, int num); // Masukin angka di index tertentu
  25. int back(node *head); // Ambil angka paling belakang
  26. int front(node *head); // Ambil angka terdepan
  27. int getAt(node *head, int index); // Ambil angka pada index tertentu
  28. void popBack(node *head); // Buang belakang
  29. void popFront(node **head); // Buang depan
  30. void removeAt(node **head, int index); // Remove data di index ke sekian
  31.  
  32. void unload(node *head); // Unload dictionary from memory
  33. void randomAdd(node **head); // RNG
  34. void forEachElement(node *head, char *command); // Perintah untuk tiap elemen
  35.     // Command
  36.     void printElement(node *head); // Print element (node)
  37.     void multiply2(node *head); // Mengalikan setiap element dgn 2
  38.     void reverseEach(node *head); // Membalik setiap digit
  39.     void sumDigit(node *head); // Ganti elemen dengan jumlah digitnya
  40.  
  41. int main(void)
  42. {
  43.     node *head = NULL;
  44.  
  45.     // Isi Linked List
  46.     int in;
  47.     printf("Input: ");
  48.     while (1)
  49.     {
  50.         if (!scanf("%d", &in)) break;
  51.         else if (in == 0) randomAdd(&head);
  52.         else pushFront(&head, in);
  53.     }
  54.  
  55.     pushBack(head, 505);
  56.     insertAt(&head, 1, 10000);
  57.     insertAt(&head, 100000, 321);
  58.  
  59.     forEachElement(head, "printElement");
  60.  
  61.     forEachElement(head, "multiply2");
  62.     forEachElement(head, "printElement");
  63.  
  64.     forEachElement(head, "reverseEach");
  65.     forEachElement(head, "printElement");
  66.  
  67.     forEachElement(head, "sumDigit");
  68.     forEachElement(head, "printElement");
  69.  
  70.     popBack(head);
  71.     popFront(&head);
  72.     forEachElement(head, "printElement");
  73.  
  74.     printf("Front: %d\n", front(head));
  75.     printf("Back: %d\n", back(head));
  76.     printf("Get at 3: %d\n", getAt(head, 3));
  77.  
  78.     unload(head);
  79.     return 0;
  80. }
  81.  
  82. void popFront(node **head)
  83. {
  84.     if (*head)
  85.     {
  86.         node *trav = *head;
  87.         *head = trav->next;
  88.         free(trav);
  89.     }
  90.     return;
  91. }
  92.  
  93. void popBack(node *head)
  94. {
  95.     if (head)
  96.     {
  97.         node *trav = head;
  98.  
  99.         // Traverse every linked list
  100.         while (trav->next->next)
  101.             trav = trav->next;
  102.  
  103.         free(trav->next);
  104.         trav->next = NULL;
  105.     }
  106.     return;
  107. }
  108.  
  109. int getAt(node *head, int index)
  110. {
  111.     if (!head) return 0;
  112.  
  113.     if (index == 0) return front(head);
  114.     else if (index >= size - 1) return back(head);
  115.  
  116.     node *trav = head;
  117.  
  118.     // Traverse every linked list
  119.     for (int i = 0; i < index && trav->next; i++)
  120.     {
  121.         trav = trav->next;
  122.     }
  123.  
  124.     return trav->x;
  125. }
  126.  
  127. int front(node *head)
  128. {
  129.     if (!head) return 0;
  130.     node *trav = head;
  131.     return trav->x;
  132. }
  133.  
  134. int back(node *head)
  135. {
  136.     if (!head) return 0;
  137.     node *trav = head;
  138.  
  139.     // Traverse every linked list
  140.     while (trav->next)
  141.         trav = trav->next;
  142.  
  143.     return trav->x;
  144. }
  145.  
  146. void insertAt(node **head, int index, int num)
  147. {
  148.     if (index == 0 || !*head) pushFront(head, num);
  149.     else if (index >= size - 1) pushBack(*head, num);
  150.     else
  151.     {
  152.         node *trav = *head;
  153.         for (int i = 0; i < index - 1; i++)
  154.         {
  155.             if (trav->next)
  156.                 trav = trav->next;
  157.             else
  158.             {
  159.                 pushBack(*head, num);
  160.                 return;
  161.             }
  162.         }
  163.         // Make new node
  164.         node *n = malloc(sizeof(node));
  165.         if (!n) return;
  166.         n->x = num;
  167.  
  168.         // Insert node
  169.         n->next = trav->next;
  170.         trav->next = n;
  171.         size++;
  172.     }
  173.     return;
  174. }
  175.  
  176. void pushBack(node *head, int num)
  177. {
  178.     if (!head) return;
  179.  
  180.     node *trav = head;
  181.  
  182.     // Traverse to back
  183.     while (trav->next)
  184.         trav = trav->next;
  185.  
  186.     // Make new node
  187.     node *n = malloc(sizeof(node));
  188.     if (!n) return;
  189.     n->x = num;
  190.     n->next = NULL;
  191.  
  192.     // Insert node
  193.     trav->next = n;
  194.     size++;
  195. }
  196.  
  197. void removeAt(node **head, int index)
  198. {
  199.     if (!*head) return;
  200.  
  201.     node *trav = *head;
  202.  
  203.     if (index >= size) index = size - 1; // Popback
  204.     else if (index < 0) index = 0; // Popfront
  205.  
  206.     for (int i = 0; i < index - 1; i++)
  207.         trav = trav->next;
  208.  
  209.     node *nextHead = trav->next->next;
  210.     free(trav->next);
  211.     trav->next = nextHead;
  212.     size--;
  213.  
  214.     return;
  215. }
  216.  
  217. void printElement(node *head)
  218. {
  219.     node *trav = head;
  220.     while (trav)
  221.     {
  222.         printf("%d ", trav->x);
  223.         trav = trav->next;
  224.     }
  225.     printf("\n");
  226.     return;
  227. }
  228.  
  229. void multiply2(node *head)
  230. {
  231.     node *trav = head;
  232.     while (trav)
  233.     {
  234.         trav->x *= 2;
  235.         trav = trav->next;
  236.     }
  237.     return;
  238. }
  239.  
  240. void reverseEach(node *head)
  241. {
  242.     node *trav = head;
  243.     while (trav)
  244.     {
  245.         int num = trav->x;
  246.         trav->x= 0;
  247.         int prev = 1;
  248.         for (int i = 0; num != 0; i++)
  249.         {
  250.             trav->x *= 10;
  251.             int adder = num % 10; // Ambil dari belakang
  252.             // if ((i == 0 || prev == 0) && adder == 0) printf("0");
  253.             trav->x += adder;
  254.             prev = adder;
  255.             num /= 10;
  256.         }
  257.         trav = trav->next;
  258.     }
  259.     return;
  260. }
  261.  
  262. void sumDigit(node *head)
  263. {
  264.     node *trav = head;
  265.     while (trav)
  266.     {
  267.         int num = trav->x;
  268.         trav->x = 0;
  269.         while (num != 0)
  270.         {
  271.             trav->x += (num % 10);
  272.             num /= 10;
  273.         }
  274.         trav = trav->next;
  275.     }
  276.     return;
  277. }
  278.  
  279. void forEachElement(node *head, char *command)
  280. {
  281.     if (strcmp((char*)"printElement", command) == 0)
  282.         printElement(head);
  283.  
  284.     else if (strcmp((char*)"multiply2", command) == 0)
  285.         multiply2(head);
  286.  
  287.     else if (strcmp((char*)"reverseEach", command) == 0)
  288.         reverseEach(head);
  289.  
  290.     else if (strcmp((char*)"sumDigit", command) == 0)
  291.         sumDigit(head);
  292.  
  293.     else printf("Fail Command\n");
  294.  
  295.     return;
  296. }
  297.  
  298. void randomAdd(node **head)
  299. {
  300.     srand(time(NULL));
  301.  
  302.     // Maks 10 item, min 3 item
  303.     int loop = rand() % 8 + 3;
  304.  
  305.     printf("Random Input: ");
  306.     for (int i = 0; i < loop; i++)
  307.     {
  308.         // Angka maks = 100
  309.         int num = rand() % 100;
  310.         printf("%d ", num);
  311.  
  312.         pushFront(head, num);
  313.     }
  314.     printf("\n");
  315. }
  316.  
  317. void pushFront(node **head, int num)
  318. {
  319.     // Make new node
  320.     node *n = malloc(sizeof(node));
  321.     if (!n) return;
  322.     n->x = num;
  323.  
  324.     // Insert node (push front)
  325.     if (head) n->next = *head;
  326.     else n->next = NULL;
  327.  
  328.     // Change head
  329.     *head = n;
  330.     size++;
  331.     return;
  332. }
  333.  
  334. void unload(node *head)
  335. {
  336.     node *trav = head;
  337.  
  338.     // Traverse every linked list
  339.     while (trav)
  340.     {
  341.         node *tmp = trav;
  342.         trav = trav->next;
  343.         free(tmp);
  344.     }
  345. }
RAW Paste Data
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
Top