fork download
copy 
  1. // P.02.01 (Operations on Singly Linked Lists)
  2. // Code by Vani 
  3.  
  4. #include <stdio.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <stdbool.h>
  8.  
  9. typedef struct Node {
  10.     int value;
  11.     struct Node* next;
  12. } Node;
  13.  
  14. Node* makeNode(int v) {
  15.     Node* p = (Node*)malloc(sizeof(Node));
  16.     if(p == NULL) return NULL;
  17.     p -> value = v;
  18.     p -> next = NULL;
  19.     return p;
  20. }
  21.  
  22. void printList(Node* h) {
  23.     Node* p = h;
  24.     while(p != NULL) {
  25.         printf("%d ", p -> value);
  26.         p = p -> next;
  27.     }
  28. }
  29.  
  30. bool find(Node* head, int val) {
  31.     Node* p = head;
  32.     while(p != NULL) {
  33.         if(p -> value == val) return true;
  34.         p = p -> next;
  35.     }
  36.     return false;
  37. }
  38.  
  39. Node* addFirst(Node* head, int v) {
  40.     if(find(head, v)) return head;
  41.     Node* new_node = makeNode(v);
  42.     new_node -> next = head;
  43.     return new_node;
  44. }
  45.  
  46. Node* addLast(Node* head, int v) {
  47.     if(find(head, v)) return head;
  48.     Node* new_node = makeNode(v);
  49.     if(head == NULL) return new_node;
  50.  
  51.     Node* p = head;
  52.     while(p -> next != NULL) p = p -> next;
  53.     p -> next = new_node;
  54.     return head;
  55. }
  56.  
  57. Node* addAfter(Node* head, int u, int v) {
  58.     if(find(head, u) || !find(head, v)) return head;
  59.     Node* p = head;
  60.     while(p != NULL && p -> value != v) p = p -> next;
  61.     if(p != NULL) {
  62.         Node* new_node = makeNode(u);
  63.         new_node -> next = p -> next;
  64.         p -> next = new_node;
  65.     }
  66.     return head;
  67. }
  68.  
  69. Node* addBefore(Node* head, int u, int v) {
  70.     if(find(head, u) || !find(head, v)) return head;
  71.     if(head != NULL && head -> value == v) {
  72.         return addFirst(head, u);
  73.     }
  74.     Node* p = head;
  75.     while(p != NULL && p -> next != NULL && p->next->value != v) p = p-> next;
  76.     if(p != NULL && p-> next != NULL) {
  77.         Node* new_node = makeNode(u);
  78.         new_node -> next = p -> next;
  79.         p -> next = new_node;
  80.     }
  81.     return head;
  82. }
  83.  
  84. Node* removeNode(Node* head, int k) {
  85.     if(head == NULL) return NULL;
  86.     if(head -> value == k) {
  87.         Node* temp = head;
  88.         head = head -> next;
  89.         free(temp);
  90.         return head;
  91.     }
  92.     Node* p = head;
  93.     while(p -> next != NULL && p -> next -> value != k) {
  94.         p = p -> next;
  95.     }
  96.     if(p -> next != NULL) {
  97.         Node* temp = p -> next;
  98.         p -> next = p -> next -> next;
  99.         free(temp);
  100.     }
  101.     return head;
  102. }
  103.  
  104. Node* reverse(Node* head) {
  105.     Node* prev = NULL;
  106.     Node* current = head;
  107.     Node* next = NULL;
  108.     while(current != NULL) {
  109.         next = current -> next;
  110.         current -> next = prev;
  111.         prev = current;
  112.         current = next;
  113.     }
  114.     return prev;
  115. }
  116.  
  117. void vaniinput() {
  118.     int n; scanf("%d", &n);
  119.     Node *head = NULL, *tail = NULL;
  120.     for(int i = 0; i < n; i++) {
  121.         int k; scanf("%d", &k);
  122.         Node *new_node = makeNode(k);
  123.         if(head == NULL) {
  124.             head = new_node;
  125.             tail = new_node;
  126.         } else {
  127.             tail -> next = new_node;
  128.             tail = new_node;
  129.         }
  130.     }
  131.  
  132.     char cmd[50];
  133.     while(scanf("%s", cmd) == 1 && strcmp(cmd, "#") != 0) {
  134.         if(strcmp(cmd, "addlast") == 0) {
  135.             int k; scanf("%d", &k);
  136.             head = addLast(head, k);
  137.         } else if(strcmp(cmd, "addfirst") == 0) {
  138.             int k; scanf("%d", &k);
  139.             head = addFirst(head, k);
  140.         } else if(strcmp(cmd, "addafter") == 0) {
  141.             int u, v; scanf("%d %d", &u, &v);
  142.             head = addAfter(head, u, v);
  143.         } else if(strcmp(cmd, "addbefore") == 0) {
  144.             int u, v; scanf("%d %d", &u, &v);
  145.             head = addBefore(head, u, v);
  146.         } else if(strcmp(cmd, "remove") == 0) {
  147.             int k; scanf("%d", &k);
  148.             head = removeNode(head, k);
  149.         } else if(strcmp(cmd, "reverse") == 0) {
  150.             head = reverse(head);
  151.         }
  152.     }
  153.  
  154.     printList(head);
  155. }
  156.  
  157. void vanimain() {
  158.     vaniinput();
  159. }
  160.  
  161. int main() {
  162.     vanimain();
  163.     return 0;
  164. }
  165.  
Success #stdin #stdout 0s 5300KB
comments (?)
stdin
copy 
5
5 4 3 2 1
addlast 3
addlast 10
addfirst 1
addafter 10 4
remove 1
#
stdout
copy 
5 4 3 2 10
https://ideone.com/NpWAqa
Operations on Singly Linked Lists
language:
C (gcc 8.3)
created:
1 day 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!