Modify contents of Linked List

03 Jul, 2022
Given a singly linked list containing n nodes. Modify the value of first half nodes such that 1st node’s new value is equal to the last node’s value minus first node’s current value, 2nd node’s new value is equal to the second last node’s value minus 2nd node’s current value, likewise for first half nodes. If n is odd then the value of the middle node remains unchanged. (No extra memory to be used).
Examples:  
Input : 10 -> 4 -> 5 -> 3 -> 6
Output : 4 -> 1 -> 5 -> 3 -> 6

Input : 2 -> 9 -> 8 -> 12 -> 7 -> 10
Output : -8 -> 2 -> -4 -> 12 -> 7 -> 10
Asked in Amazon Interview 
Approach: The following steps are:
Split the list from the middle. Perform front and back split. If the number of elements is odd, the extra element should go in the 1st(front) list.Reverse the 2nd(back) list.Perform the required subtraction while traversing both list simultaneously.Again reverse the 2nd list.Concatenate the 2nd list back to the end of the 1st list.
Split the list from the middle. Perform front and back split. If the number of elements is odd, the extra element should go in the 1st(front) list.
Reverse the 2nd(back) list.
Perform the required subtraction while traversing both list simultaneously.
Again reverse the 2nd list.
Concatenate the 2nd list back to the end of the 1st list.
C++
Java
Python3
C#
Javascript
// C++ implementation to modify the contents of // the linked list#include <bits/stdc++.h>using namespace std;  /* Linked list node */struct Node{    int data;    struct Node* next;};  /* function prototype for printing the list */void printList(struct Node*);  /* Function to insert a node at the beginning of    the linked list */void push(struct Node **head_ref, int new_data){  /* allocate node */  struct Node* new_node =            (struct Node*) malloc(sizeof(struct Node));      /* put in the data  */  new_node->data = new_data;      /* link the old list at the end of the new node */  new_node->next = *head_ref;          /* move the head to point to the new node */  *head_ref = new_node;}   /* Split the nodes of the given list    into front and back halves,   and return the two lists    using the reference parameters.   Uses the fast/slow pointer strategy. */void frontAndBackSplit(struct Node *head,                struct Node **front_ref, struct Node **back_ref){    Node *slow, *fast;          slow = head;    fast = head->next;          /* Advance 'fast' two nodes, and        advance 'slow' one node */    while (fast != NULL)    {        fast = fast->next;        if (fast != NULL)        {            slow = slow->next;            fast = fast->next;        }    }           /* 'slow' is before the midpoint in the list,         so split it in two at that point. */    *front_ref = head;    *back_ref = slow->next;    slow->next = NULL;}  /* Function to reverse the linked list */void reverseList(struct Node **head_ref){    struct Node *current, *prev, *next;    current = *head_ref;    prev = NULL;    while (current != NULL)    {        next = current->next;        current->next = prev;        prev = current;        current = next;    }        *head_ref = prev;}  // perform the required subtraction operation on// the 1st half of the linked listvoid modifyTheContentsOf1stHalf(struct Node *front,                                struct Node *back){    // traversing both the lists simultaneously    while (back != NULL)    {        // subtraction operation and node data        // modification        front->data = front->data - back->data;                  front = front->next;        back = back->next;    }}  // function to concatenate the 2nd(back) list at the end of// the 1st(front) list and returns the head of the new liststruct Node* concatFrontAndBackList(struct Node *front,                                    struct Node *back){    struct Node *head = front;          while (front->next != NULL)        front = front->next;                  front->next    = back;          return head;}  // function to modify the contents of the linked liststruct Node* modifyTheList(struct Node *head){    // if list is empty or contains only single node    if (!head || head->next == NULL)        return head;          struct Node *front, *back;          // split the list into two halves    // front and back lists    frontAndBackSplit(head, &front, &back);                  // reverse the 2nd(back) list    reverseList(&back);          // modify the contents of 1st half        modifyTheContentsOf1stHalf(front, back);              // agains reverse the 2nd(back) list    reverseList(&back);          // concatenating the 2nd list back to the     // end of the 1st list    head = concatFrontAndBackList(front, back);          // pointer to the modified list    return head;}  // function to print the linked listvoid printList(struct Node *head){    if (!head)        return;          while (head->next != NULL)    {        cout << head->data << " -> ";        head = head->next;    }    cout << head->data << endl;}  // Driver program to test aboveint main(){    struct Node *head = NULL;          // creating the linked list    push(&head, 10);    push(&head, 7);    push(&head, 12);    push(&head, 8);    push(&head, 9);    push(&head, 2);          // modify the linked list    head = modifyTheList(head);          // print the modified linked list    cout << "Modified List:" << endl;    printList(head);    return 0;} 
// Java implementation to modify the contents // of the linked listclass GFG{      /* Linked list node */static class Node{    int data;    Node next;};  /* Function to insert a node at the beginning of the linked list */static Node push(Node head_ref, int new_data){    /* allocate node */    Node new_node =new Node();    /* put in the data */    new_node.data = new_data;              /* link the old list at the end     of the new node */    new_node.next = head_ref;               /* move the head to point to the new node */    head_ref = new_node;          return head_ref;}   static Node front,back;  /* Split the nodes of the given list into front and back halves,and return the two lists using the reference parameters.Uses the fast/slow pointer strategy. */static void frontAndBackSplit( Node head){    Node slow, fast;          slow = head;    fast = head.next;          /* Advance 'fast' two nodes, and     advance 'slow' one node */    while (fast != null)    {        fast = fast.next;        if (fast != null)        {            slow = slow.next;            fast = fast.next;        }    }          /* 'slow' is before the midpoint in the list,         so split it in two at that point. */    front = head;    back = slow.next;    slow.next = null;}  /* Function to reverse the linked list */static Node reverseList( Node head_ref){    Node current, prev, next;    current = head_ref;    prev = null;    while (current != null)    {        next = current.next;        current.next = prev;        prev = current;        current = next;    }     head_ref = prev;    return head_ref;}  // perform the required subtraction operation // on the 1st half of the linked liststatic void modifyTheContentsOf1stHalf(){    Node front1 = front, back1 = back;    // traversing both the lists simultaneously    while (back1 != null)    {        // subtraction operation and node data        // modification        front1.data = front1.data - back1.data;                  front1 = front1.next;        back1 = back1.next;    }}  // function to concatenate the 2nd(back) list // at the end of the 1st(front) list and // returns the head of the new liststatic Node concatFrontAndBackList(Node front,                                   Node back){    Node head = front;          if(front == null)return back;          while (front.next != null)        front = front.next;               front.next = back;          return head;}  // function to modify the contents of the linked liststatic Node modifyTheList( Node head){    // if list is empty or contains only single node    if (head == null || head.next == null)        return head;    front = null; back = null;          // split the list into two halves    // front and back lists    frontAndBackSplit(head);              // reverse the 2nd(back) list    back = reverseList(back);          // modify the contents of 1st half     modifyTheContentsOf1stHalf();          // agains reverse the 2nd(back) list    back = reverseList(back);          // concatenating the 2nd list back to the     // end of the 1st list    head = concatFrontAndBackList(front, back);      // pointer to the modified list    return head;}  // function to print the linked liststatic void printList( Node head){    if (head == null)        return;          while (head.next != null)    {        System.out.print(head.data + " -> ");        head = head.next;    }    System.out.println(head.data );}  // Driver Codepublic static void main(String args[]){    Node head = null;          // creating the linked list    head = push(head, 10);    head = push(head, 7);    head = push(head, 12);    head = push(head, 8);    head = push(head, 9);    head = push(head, 2);          // modify the linked list    head = modifyTheList(head);          // print the modified linked list    System.out.println( "Modified List:" );    printList(head);}}  // This code is contributed by Arnab Kundu
# Python3 implementation to modify the contents # of the linked list  # Linked list node class Node:           def __init__(self, data):         self.data = data         self.next = None  # Function to insert a node at the beginning # of the linked list def push(head_ref, new_data):      # allocate node     new_node =Node(0)          # put in the data     new_node.data = new_data              # link the old list at the end     #of the new node     new_node.next = head_ref               # move the head to point to the new node     head_ref = new_node          return head_ref  front = Noneback = None  # Split the nodes of the given list # into front and back halves,# and return the two lists # using the reference parameters.# Uses the fast/slow pointer strategy. def frontAndBackSplit( head):      global front    global back    slow = None    fast = None          slow = head    fast = head.next          # Advance 'fast' two nodes, and     # advance 'slow' one node     while (fast != None):              fast = fast.next        if (fast != None):            slow = slow.next            fast = fast.next      # 'slow' is before the midpoint in the list,     # so split it in two at that point.     front = head    back = slow.next    slow.next = None    return head  # Function to reverse the linked list def reverseList( head_ref):      current = None    prev = None    next = None    current = head_ref    prev = None    while (current != None):              next = current.next        current.next = prev        prev = current        current = next          head_ref = prev    return head_ref  # perform the required subtraction operation # on the 1st half of the linked listdef modifyTheContentsOf1stHalf():      global front    global back    front1 = front    back1 = back          # traversing both the lists simultaneously    while (back1 != None):              # subtraction operation and node data        # modification        front1.data = front1.data - back1.data                  front1 = front1.next        back1 = back1.next      # function to concatenate the 2nd(back) list # at the end of the 1st(front) list and # returns the head of the new listdef concatFrontAndBackList( front, back):          head = front          if(front == None):        return back          while (front.next != None):        front = front.next              front.next = back    return head  # function to modify the contents of the linked listdef modifyTheList( head):      global front    global back      # if list is empty or contains only single node    if (head == None or head.next == None):        return head    front = None    back = None          # split the list into two halves    # front and back lists    frontAndBackSplit(head)              # reverse the 2nd(back) list    back = reverseList(back)          # modify the contents of 1st half     modifyTheContentsOf1stHalf()          # agains reverse the 2nd(back) list    back = reverseList(back)          # concatenating the 2nd list back to the     # end of the 1st list    head = concatFrontAndBackList(front, back)      # pointer to the modified list    return head  # function to print the linked listdef printList( head):      if (head == None):        return          while (head.next != None):              print(head.data , " -> ",end="")        head = head.next          print(head.data )  # Driver Code  head = None      # creating the linked listhead = push(head, 10)head = push(head, 7)head = push(head, 12)head = push(head, 8)head = push(head, 9)head = push(head, 2)      # modify the linked listhead = modifyTheList(head)      # print the modified linked listprint( "Modified List:" )printList(head)  # This code is contributed by Arnab Kundu
// C# implementation to modify the // contents of the linked listusing System;  class GFG{      /* Linked list node */public class Node{    public int data;    public Node next;};  /* Function to insert a node at the beginning of the linked list */static Node push(Node head_ref,                   int new_data){    /* allocate node */    Node new_node = new Node();          /* put in the data */    new_node.data = new_data;              /* link the old list at the end     of the new node */    new_node.next = head_ref;               /* move the head to point to the new node */    head_ref = new_node;          return head_ref;}   static Node front, back;  /* Split the nodes of the given list into front and back halves,and return the two lists using the reference parameters.Uses the fast/slow pointer strategy. */static void frontAndBackSplit( Node head){    Node slow, fast;          slow = head;    fast = head.next;          /* Advance 'fast' two nodes, and     advance 'slow' one node */    while (fast != null)    {        fast = fast.next;        if (fast != null)        {            slow = slow.next;            fast = fast.next;        }    }          /* 'slow' is before the midpoint in the list,         so split it in two at that point. */    front = head;    back = slow.next;    slow.next = null;}  /* Function to reverse the linked list */static Node reverseList(Node head_ref){    Node current, prev, next;    current = head_ref;    prev = null;    while (current != null)    {        next = current.next;        current.next = prev;        prev = current;        current = next;    }     head_ref = prev;    return head_ref;}  // perform the required subtraction operation // on the 1st half of the linked liststatic void modifyTheContentsOf1stHalf(){    Node front1 = front, back1 = back;          // traversing both the lists simultaneously    while (back1 != null)    {        // subtraction operation and node data        // modification        front1.data = front1.data - back1.data;                  front1 = front1.next;        back1 = back1.next;    }}  // function to concatenate the 2nd(back) list // at the end of the 1st(front) list and // returns the head of the new liststatic Node concatFrontAndBackList(Node front,                                   Node back){    Node head = front;          if(front == null)        return back;          while (front.next != null)        front = front.next;               front.next = back;          return head;}  // function to modify the contents of// the linked liststatic Node modifyTheList(Node head){    // if list is empty or contains     // only single node    if (head == null || head.next == null)        return head;    front = null; back = null;          // split the list into two halves    // front and back lists    frontAndBackSplit(head);              // reverse the 2nd(back) list    back = reverseList(back);          // modify the contents of 1st half     modifyTheContentsOf1stHalf();          // agains reverse the 2nd(back) list    back = reverseList(back);          // concatenating the 2nd list back to the     // end of the 1st list    head = concatFrontAndBackList(front, back);      // pointer to the modified list    return head;}  // function to print the linked liststatic void printList( Node head){    if (head == null)        return;          while (head.next != null)    {        Console.Write(head.data + " -> ");        head = head.next;    }    Console.WriteLine(head.data );}  // Driver Codepublic static void Main(){    Node head = null;          // creating the linked list    head = push(head, 10);    head = push(head, 7);    head = push(head, 12);    head = push(head, 8);    head = push(head, 9);    head = push(head, 2);          // modify the linked list    head = modifyTheList(head);          // print the modified linked list    Console.WriteLine( "Modified List:" );    printList(head);}}  // This code is contributed by PrinciRaj1992
<script>        // JavaScript implementation to modify the      // contents of the linked list      /* Linked list node */      class Node {        constructor() {          this.data = 0;          this.next = null;        }      }        /* Function to insert a node at       the beginning of the linked list */       function push(head_ref, new_data) {        /* allocate node */        var new_node = new Node();          /* put in the data */        new_node.data = new_data;          /* link the old list at the end    of the new node */        new_node.next = head_ref;          /* move the head to point to the new node */        head_ref = new_node;          return head_ref;      }        var front, back;        /* Split the nodes of the given list         into front and back halves,         and return the two lists         using the reference parameters.         Uses the fast/slow pointer strategy. */      function frontAndBackSplit(head) {        var slow, fast;          slow = head;        fast = head.next;          /* Advance 'fast' two nodes, and    advance 'slow' one node */        while (fast != null) {          fast = fast.next;          if (fast != null) {            slow = slow.next;            fast = fast.next;          }        }          /* 'slow' is before the midpoint in the list,        so split it in two at that point. */        front = head;        back = slow.next;        slow.next = null;      }        /* Function to reverse the linked list */      function reverseList(head_ref) {        var current, prev, next;        current = head_ref;        prev = null;        while (current != null) {          next = current.next;          current.next = prev;          prev = current;          current = next;        }        head_ref = prev;        return head_ref;      }        // perform the required subtraction operation      // on the 1st half of the linked list      function modifyTheContentsOf1stHalf() {        var front1 = front,          back1 = back;          // traversing both the lists simultaneously        while (back1 != null) {          // subtraction operation and node data          // modification          front1.data = front1.data - back1.data;            front1 = front1.next;          back1 = back1.next;        }      }        // function to concatenate the 2nd(back) list      // at the end of the 1st(front) list and      // returns the head of the new list      function concatFrontAndBackList(front, back) {        var head = front;          if (front == null) return back;          while (front.next != null) front = front.next;          front.next = back;          return head;      }        // function to modify the contents of      // the linked list      function modifyTheList(head) {        // if list is empty or contains        // only single node        if (head == null || head.next == null) return head;        front = null;        back = null;          // split the list into two halves        // front and back lists        frontAndBackSplit(head);          // reverse the 2nd(back) list        back = reverseList(back);          // modify the contents of 1st half        modifyTheContentsOf1stHalf();          // agains reverse the 2nd(back) list        back = reverseList(back);          // concatenating the 2nd list back to the        // end of the 1st list        head = concatFrontAndBackList(front, back);          // pointer to the modified list        return head;      }        // function to print the linked list      function printList(head) {        if (head == null) return;          while (head.next != null) {          document.write(head.data + " -> ");          head = head.next;        }        document.write(head.data + "<br>");      }        // Driver Code      var head = null;        // creating the linked list      head = push(head, 10);      head = push(head, 7);      head = push(head, 12);      head = push(head, 8);      head = push(head, 9);      head = push(head, 2);        // modify the linked list      head = modifyTheList(head);        // print the modified linked list      document.write("Modified List: <br>");      printList(head);        </script>
Output: 
Modified List:
-8 -> 2 -> -4 -> 12 -> 7 -> 10
Time Complexity: O(n), where n in the number of nodes.
Space complexity: O(1) since using constant space to modify pointers
Another approach (Using Stack) : 1. Find the starting point of second half Linked List. 2. Push all elements of second half list into stack s. 3. Traverse list starting from head using temp until stack is not empty and do Modify temp->data by subtracting the top element of stack for every node.
Below is the implementation using stack. 
C++
Java
Python3
C#
Javascript
// C++ implementation to modify the// contents of the linked list#include <bits/stdc++.h>using namespace std;  // Linked list nodestruct Node{    int data;    struct Node* next;};  // function prototype for printing the listvoid printList(struct Node*);  // Function to insert a node at the// beginning of the linked listvoid push(struct Node **head_ref, int new_data){  // allocate nodestruct Node* new_node =            (struct Node*) malloc(sizeof(struct Node));  // put in the datanew_node->data = new_data;  // link the old list at the end of the new nodenew_node->next = *head_ref;   // move the head to point to the new node*head_ref = new_node;}   // function to print the linked listvoid printList(struct Node *head){    if (!head)        return;          while (head->next != NULL)    {        cout << head->data << " -> ";        head = head->next;    }    cout << head->data << endl;}  // Function to middle node of list.Node* find_mid(Node *head){    Node *temp = head, *slow = head, *fast = head ;          while(fast && fast->next)    {              // Advance 'fast' two nodes, and     // advance 'slow' one node    slow = slow->next ;    fast = fast->next->next ;    }          // If number of nodes are odd then update slow    // by slow->next;    if(fast)    slow = slow->next ;  return slow ;}  // function to modify the contents of the linked list.void modifyTheList(struct Node *head, struct Node *slow){// Create Stack. stack <int> s;Node *temp = head ;  while(slow){    s.push( slow->data ) ;    slow = slow->next ;}  // Traverse the list by using temp until stack is empty.while( !s.empty() ){    temp->data = temp->data - s.top() ;    temp = temp->next ;    s.pop() ;}  }  // Driver program to test aboveint main(){    struct Node *head = NULL, *mid ;          // creating the linked list    push(&head, 10);    push(&head, 7);    push(&head, 12);    push(&head, 8);    push(&head, 9);    push(&head, 2);          // Call Function to Find the starting point of second half of list.     mid = find_mid(head) ;          // Call function to modify the contents of the linked list.    modifyTheList( head, mid);                // print the modified linked list    cout << "Modified List:" << endl;    printList(head);    return 0;}   // This is contributed by Mr. Gera
// Java implementation to modify the// contents of the linked listimport java.util.*;  class GFG {      // Linked list node    static class Node     {          int data;        Node next;    };      // Function to insert a node at the    // beginning of the linked list    static Node push(Node head_ref, int new_data)     {          // allocate node        Node new_node = new Node();          // put in the data        new_node.data = new_data;          // link the old list at the end of the new node        new_node.next = head_ref;          // move the head to point to the new node        head_ref = new_node;        return head_ref;    }      // function to print the linked list    static void printList(Node head)     {        if (head == null)         {            return;        }          while (head.next != null)         {            System.out.print(head.data + "->");            head = head.next;        }        System.out.print(head.data + "\n");    }      // Function to middle node of list.    static Node find_mid(Node head)     {        Node temp = head, slow = head, fast = head;          while (fast != null && fast.next != null)        {              // Advance 'fast' two nodes, and             // advance 'slow' one node            slow = slow.next;            fast = fast.next.next;        }          // If number of nodes are odd then update slow        // by slow.next;        if (fast != null)         {            slow = slow.next;        }          return slow;    }      // function to modify the contents of the linked list.    static void modifyTheList(Node head, Node slow)     {        // Create Stack.         Stack<Integer> s = new Stack<Integer>();        Node temp = head;          while (slow != null)         {            s.add(slow.data);            slow = slow.next;        }      // Traverse the list by using temp until stack is empty.        while (!s.empty())        {            temp.data = temp.data - s.peek();            temp = temp.next;            s.pop();        }      }      // Driver program to test above    public static void main(String[] args)    {        Node head = null, mid;          // creating the linked list        head = push(head, 10);        head = push(head, 7);        head = push(head, 12);        head = push(head, 8);        head = push(head, 9);        head = push(head, 2);          // Call Function to Find the starting        // point of second half of list.         mid = find_mid(head);          // Call function to modify         // the contents of the linked list.        modifyTheList(head, mid);          // print the modified linked list        System.out.print("Modified List:" + "\n");        printList(head);    }}  // This code is contributed by Rajput-Ji
# Python3 implementation to modify the# contents of the linked list   # Linked list nodeclass Node:          def __init__(self):                  self.data = 0        self.next = None   # Function to insert a node at the# beginning of the linked listdef append(head_ref, new_data):      # Allocate node    new_node = Node()          # Put in the data    new_node.data = new_data          # Link the old list at the end    # of the new node    new_node.next = head_ref           # Move the head to point to the new node    head_ref = new_node          return head_ref      # Function to print the linked listdef printList(head):      if (not head):        return;           while (head.next != None):        print(head.data, end = ' -> ')        head = head.next          print(head.data)      # Function to middle node of list.def find_mid(head):      temp = head    slow = head    fast = head            while (fast and fast.next):                  # Advance 'fast' two nodes, and         # advance 'slow' one node        slow = slow.next         fast = fast.next.next               # If number of nodes are odd then     # update slow by slow.next;    if (fast):        slow = slow.next        return slow   # Function to modify the contents of # the linked list.def modifyTheList(head, slow):      # Create Stack.     s = []    temp = head           while (slow):        s.append(slow.data)         slow = slow.next       # Traverse the list by using     # temp until stack is empty.    while (len(s) != 0):        temp.data = temp.data - s[-1]        temp = temp.next         s.pop()       # Driver codeif __name__=='__main__':          head = None           # creating the linked list    head = append(head, 10)    head = append(head, 7)    head = append(head, 12)    head = append(head, 8)    head = append(head, 9)    head = append(head, 2)           # Call Function to Find the     # starting point of second half of list.     mid = find_mid(head)            # Call function to modify the     # contents of the linked list.    modifyTheList( head, mid)           # Print the modified linked list    print("Modified List:")    printList(head)  # This code is contributed by rutvik_56
// C# implementation to modify the// contents of the linked listusing System;using System.Collections.Generic;  class GFG {      // Linked list node    public class Node     {          public int data;        public Node next;    };      // Function to insert a node at the    // beginning of the linked list    static Node push(Node head_ref, int new_data)     {          // allocate node        Node new_node = new Node();          // put in the data        new_node.data = new_data;          // link the old list at the end of the new node        new_node.next = head_ref;          // move the head to point to the new node        head_ref = new_node;        return head_ref;    }      // function to print the linked list    static void printList(Node head)     {        if (head == null)         {            return;        }          while (head.next != null)         {            Console.Write(head.data + "->");            head = head.next;        }        Console.Write(head.data + "\n");    }      // Function to middle node of list.    static Node find_mid(Node head)     {        Node temp = head, slow = head, fast = head;          while (fast != null && fast.next != null)        {              // Advance 'fast' two nodes, and             // advance 'slow' one node            slow = slow.next;            fast = fast.next.next;        }          // If number of nodes are odd then update slow        // by slow.next;        if (fast != null)         {            slow = slow.next;        }          return slow;    }      // function to modify the contents of the linked list.    static void modifyTheList(Node head, Node slow)     {        // Create Stack.         Stack<int> s = new Stack<int>();        Node temp = head;          while (slow != null)         {            s.Push(slow.data);            slow = slow.next;        }          // Traverse the list by using temp until stack is empty.        while (s.Count != 0)        {            temp.data = temp.data - s.Peek();            temp = temp.next;            s.Pop();        }      }      // Driver code    public static void Main(String[] args)    {        Node head = null, mid;          // creating the linked list        head = push(head, 10);        head = push(head, 7);        head = push(head, 12);        head = push(head, 8);        head = push(head, 9);        head = push(head, 2);          // Call Function to Find the starting        // point of second half of list.         mid = find_mid(head);          // Call function to modify         // the contents of the linked list.        modifyTheList(head, mid);          // print the modified linked list        Console.Write("Modified List:" + "\n");        printList(head);    }}  // This code is contributed by PrinciRaj1992
<script>  // JavaScript implementation to modify the// contents of the linked list      // Linked list nodeclass Node {    constructor(val) {        this.data = val;        this.next = null;    }}      // Function to insert a node at the    // beginning of the linked list    function push(head_ref , new_data) {          // allocate node        var new_node = new Node();          // put in the data        new_node.data = new_data;          // link the old list at the end of the new node        new_node.next = head_ref;          // move the head to point to the new node        head_ref = new_node;        return head_ref;    }      // function to print the linked list    function printList(head) {        if (head == null) {            return;        }          while (head.next != null) {            document.write(head.data + "->");            head = head.next;        }        document.write(head.data + "<br/>");    }      // Function to middle node of list.    function find_mid(head) {    var temp = head, slow = head, fast = head;          while (fast != null && fast.next != null) {              // Advance 'fast' two nodes, and            // advance 'slow' one node            slow = slow.next;            fast = fast.next.next;        }          // If number of nodes are odd then update slow        // by slow.next;        if (fast != null) {            slow = slow.next;        }          return slow;    }      // function to modify the contents of the linked list.    function modifyTheList(head,  slow) {        // Create Stack.        var s = [];        var temp = head;          while (slow != null) {            s.push(slow.data);            slow = slow.next;        }          // Traverse the list by using temp until stack is empty.        while (s.length!=0) {            temp.data = temp.data - s.pop();            temp = temp.next;                      }      }      // Driver program to test above              var head = null, mid;          // creating the linked list        head = push(head, 10);        head = push(head, 7);        head = push(head, 12);        head = push(head, 8);        head = push(head, 9);        head = push(head, 2);          // Call Function to Find the starting        // point of second half of list.        mid = find_mid(head);          // Call function to modify        // the contents of the linked list.        modifyTheList(head, mid);          // print the modified linked list        document.write("Modified List:" + "<br/>");        printList(head);  // This code contributed by Rajput-Ji  </script>
Output: 
Modified List:
-8 -> 2 -> -4 -> 12 -> 7 -> 10
Time Complexity : O(n) Space Complexity : O(n/2)References: https://www.careercup.com/question?id=5657550909341696
andrew1234
princiraj1992
Rajput-Ji
rutvik_56
khushboogoyal499
rdtank
surinderdawra388
arorakashish0911
polymatir3j
Amazon
Linked List
Amazon
Linked List
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Introduction to Data Structures
Merge two sorted linked lists
What is Data Structure: Types, Classifications and Applications
Find the middle of a given linked list
Linked List vs Array
Merge Sort for Linked Lists
Implementing a Linked List in Java using Class
Add two numbers represented by linked lists | Set 1
Detect and Remove Loop in a Linked List
Queue - Linked List Implementation