# Modify contents of Linked List – Recursive approach

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.

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

## Recommended: Please solve it on “PRACTICE” first, before moving on to the solution.

Approach: Traverse the link list using recursion for only second half of the list rather than recursing the whole list, thereby reducing the stack frame. Based on the number of nodes in the list, we calculate the starting point for the second half of the list and the list is recursed for the second half. Once the second half is recursed completely, the value of the node present in the stack and the value of the current node is subtracted.

Below is the implementation of the above approach:

 `// C++ program to modify the contents ` `// of the linked list with recursion ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Represents a Node of the linked list ` `struct` `Node { ` `    ``int` `data; ` `    ``Node* next; ` `}; ` ` `  `// Function to create and return a new node ` `Node* insert(``int` `data) ` `{ ` `    ``Node* temp; ` `    ``temp = ``new` `Node; ` `    ``temp->data = data; ` `    ``temp->next = NULL; ` `    ``return` `temp; ` `} ` ` `  `// Function which returns the total number of  ` `// node present in the list ` `int` `getTotalNodeCount(Node* head) ` `{ ` `    ``int` `totalNodesCount = 0; ` `     `  `    ``while``(head != NULL) ` `    ``{ ` `        ``totalNodesCount++; ` `        ``head = head->next; ` `    ``} ` `    ``return` `totalNodesCount; ` `} ` ` `  `// Function to modify the contents ` `// of the given linked lists ` `void` `modifyContents(Node** first_half ,  ` `                        ``Node* second_half)  ` `{ ` `    ``if` `(second_half == NULL) ` `    ``{ ` `        ``return``; ` `    ``} ` `     `  `    ``modifyContents(first_half,second_half->next); ` `     `  `    ``(*first_half)->data = second_half->data - (*first_half)->data; ` `    ``(*first_half) = (*first_half)->next; ` `     `  `    ``return``; ` `} ` ` `  `// Wrapper function which calculates the starting  ` `// point for second half of the list ` `void` `modifyContentsWrapper(Node** head) ` `{ ` `    ``Node *ptr = NULL; ``// pointer to second half of list ` `    ``Node *temp = NULL;  ` `    ``int` `diff = 0;  ` `    ``int` `length = 0; ``// number of nodes in the list ` `     `  `    ``if` `(*head == NULL) ` `    ``{ ` `        ``return``; ` `    ``} ` `    ``length = getTotalNodeCount(*head); ` `     `  `    ``// If link list has odd number of nodes, then pointer  ` `    ``// for second half starts from (length of link list + 1). ` `    ``// Say for an example, for the list 10->4->5->3->6 pointer  ` `    ``// should start from 3. ` `    ``// If list has even number of nodes, 10->4->5->9->6->8,  ` `    ``// pointer starts from 9. ` `    ``diff = (length%2 == 0? (length/2) :(length/2)+1 ); ` `     `  `    ``ptr = *head; ` ` `  `    ``while``(diff--) ` `        ``ptr = ptr->next; ` ` `  `    ``temp = *head; ` ` `  `    ``modifyContents(&temp,ptr); ` ` `  `    ``return``; ` `} ` ` `  `// Function to print the contents of the linked list ` `void` `print(Node* nod) ` `{ ` `    ``if` `(nod == NULL) { ` `        ``return``; ` `    ``} ` `     `  `    ``cout << nod->data; ` `     `  `    ``if` `(nod->next != NULL) ` `        ``cout << ``" -> "``; ` `     `  `    ``print(nod->next); ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``Node* head = insert(2); ` `    ``head->next = insert(9); ` `    ``head->next->next = insert(8); ` `    ``head->next->next->next = insert(12); ` `    ``head->next->next->next->next = insert(7); ` `    ``head->next->next->next->next->next = insert(10); ` `     `  `    ``// Modify the linked list ` `    ``modifyContentsWrapper(&head); ` ` `  `    ``// Print the modified linked list ` `    ``print(head); ` `     `  `    ``return` `0; ` `} `

 `// Java program to modify the contents ` `// of the linked list with recursion ` `class` `GFG ` `{ ` ` `  `// Represents a Node of the linked list ` `static` `class` `Node  ` `{ ` `    ``int` `data; ` `    ``Node next; ` `}; ` ` `  `// Function to create and return a new node ` `static` `Node insert(``int` `data) ` `{ ` `    ``Node temp; ` `    ``temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.next = ``null``; ` `    ``return` `temp; ` `} ` ` `  `// Function which returns the total number  ` `// of node present in the list ` `static` `int` `getTotalNodeCount(Node head) ` `{ ` `    ``int` `totalNodesCount = ``0``; ` `     `  `    ``while``(head != ``null``) ` `    ``{ ` `        ``totalNodesCount++; ` `        ``head = head.next; ` `    ``} ` `    ``return` `totalNodesCount; ` `} ` ` `  `static` `Node temp = ``null``; ` ` `  `// Function to modify the contents ` `// of the given linked lists ` `static` `void` `modifyContents(Node second_half)  ` `{ ` `    ``if` `(second_half == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` `     `  `    ``modifyContents(second_half.next); ` `     `  `    ``(temp).data = second_half.data - (temp).data; ` `    ``(temp) = (temp).next; ` `     `  `    ``return``; ` `} ` ` `  `// Wrapper function which calculates the starting  ` `// point for second half of the list ` `static` `Node modifyContentsWrapper(Node head) ` `{ ` `    ``Node ptr = ``null``; ``// pointer to second half of list ` `    ``temp = ``null``;  ` `    ``int` `diff = ``0``;  ` `    ``int` `length = ``0``; ``// number of nodes in the list ` `     `  `    ``if` `(head == ``null``) ` `    ``{ ` `        ``return` `null``; ` `    ``} ` `    ``length = getTotalNodeCount(head); ` `     `  `    ``// If link list has odd number of nodes,  ` `    ``// then pointer for second half starts  ` `    ``// from (length of link list + 1).  ` `    ``// Say for an example, for the list 10.4.5.3.6   ` `    ``// pointer should start from 3. ` `    ``// If list has even number of nodes,  ` `    ``// 10.4.5.9.6.8, pointer starts from 9. ` `    ``diff = (length % ``2` `== ``0` `?  ` `               ``(length / ``2``) : (length / ``2``) + ``1``); ` `     `  `    ``ptr = head; ` ` `  `    ``while``(diff-->``0``) ` `        ``ptr = ptr.next; ` ` `  `    ``temp = head; ` ` `  `    ``modifyContents(ptr); ` ` `  `    ``return` `head; ` `} ` ` `  `// Function to print the contents ` `// of the linked list ` `static` `void` `print(Node nod) ` `{ ` `    ``if` `(nod == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` `     `  `    ``System.out.print( nod.data); ` `     `  `    ``if` `(nod.next != ``null``) ` `        ``System.out.print( ``" -> "``); ` `     `  `    ``print(nod.next); ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String args[]) ` `{ ` `    ``Node head = insert(``2``); ` `    ``head.next = insert(``9``); ` `    ``head.next.next = insert(``8``); ` `    ``head.next.next.next = insert(``12``); ` `    ``head.next.next.next.next = insert(``7``); ` `    ``head.next.next.next.next.next = insert(``10``); ` `     `  `    ``// Modify the linked list ` `    ``head = modifyContentsWrapper(head); ` ` `  `    ``// Print the modified linked list ` `    ``print(head); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

 `# Python program to modify the contents  ` `# of the linked list with recursion  ` ` `  `# Represents a Node of the linked list  ` `class` `Node:  ` `     `  `    ``def` `__init__(``self``, data):  ` `        ``self``.data ``=` `data  ` `        ``self``.``next` `=` `None` ` `  `# Function to create and return a new node  ` `def` `insert( data) : ` ` `  `    ``temp ``=` `Node(``0``)  ` `    ``temp.data ``=` `data  ` `    ``temp.``next` `=` `None` `    ``return` `temp  ` ` `  `# Function which returns the total number  ` `# of node present in the list  ` `def` `getTotalNodeCount( head) : ` ` `  `    ``totalNodesCount ``=` `0` `     `  `    ``while``(head !``=` `None``):  ` `     `  `        ``totalNodesCount ``=` `totalNodesCount ``+` `1` `        ``head ``=` `head.``next` `     `  `    ``return` `totalNodesCount  ` ` `  `temp ``=` `None` ` `  `# Function to modify the contents  ` `# of the given linked lists  ` `def` `modifyContents( second_half) : ` ` `  `    ``if` `(second_half ``=``=` `None``):  ` `        ``return` `    ``global` `temp ` `     `  `    ``modifyContents(second_half.``next``)  ` `     `  `    ``(temp).data ``=` `second_half.data ``-` `(temp).data  ` `    ``(temp) ``=` `(temp).``next` `    ``return` ` `  `# Wrapper function which calculates the starting  ` `# point for second half of the list  ` `def` `modifyContentsWrapper(head) : ` `     `  `    ``# pointer to second half of list  ` `    ``ptr ``=` `None` `    ``diff ``=` `0` ` `  `    ``# number of nodes in the list  ` `    ``length ``=` `0` `    ``global` `temp ` `    ``temp ``=` `None` `     `  `    ``if` `(head ``=``=` `None``) : ` `        ``return` `None` `     `  `    ``length ``=` `getTotalNodeCount(head)  ` `     `  `    ``# If link list has odd number of nodes,  ` `    ``# then pointer for second half starts  ` `    ``# from (length of link list + 1).  ` `    ``# Say for an example, for the list 10.4.5.3.6  ` `    ``# pointer should start from 3.  ` `    ``# If list has even number of nodes,  ` `    ``# 10.4.5.9.6.8, pointer starts from 9.  ` `    ``if``(length ``%` `2` `=``=` `0``):  ` `        ``diff ``=` `(length ``/` `2``)  ` `    ``else``: ` `        ``diff ``=` `(length ``/` `2``) ``+` `1` `     `  `    ``ptr ``=` `head  ` ` `  `    ``while``(diff > ``0``): ` `        ``diff ``=` `diff ``-` `1` `        ``ptr ``=` `ptr.``next` ` `  `    ``temp ``=` `head  ` `    ``modifyContents(ptr)  ` `    ``return` `head  ` ` `  `# Function to print the contents  ` `# of the linked list  ` `def` `print_(nod):  ` ` `  `    ``if` `(nod ``=``=` `None``) : ` `        ``return` `     `  `    ``print``(nod.data, end ``=` `" "``) ` `     `  `    ``if` `(nod.``next` `!``=` `None``):  ` `        ``print``( ``" -> "``,end ``=` `"")  ` `     `  `    ``print_(nod.``next``)  ` ` `  `# Driver code  ` `head ``=` `insert(``2``)  ` `head.``next` `=` `insert(``9``)  ` `head.``next``.``next` `=` `insert(``8``)  ` `head.``next``.``next``.``next` `=` `insert(``12``)  ` `head.``next``.``next``.``next``.``next` `=` `insert(``7``)  ` `head.``next``.``next``.``next``.``next``.``next` `=` `insert(``10``)  ` `     `  `# Modify the linked list  ` `head ``=` `modifyContentsWrapper(head)  ` ` `  `# Print the modified linked list  ` `print_(head)  ` ` `  `# This code is contributed by Arnab Kundu  `

 `// C# program to modify the contents ` `// of the linked list with recursion ` `using` `System; ` `     `  `class` `GFG ` `{ ` ` `  `// Represents a Node of the linked list ` `public` `class` `Node  ` `{ ` `    ``public` `int` `data; ` `    ``public` `Node next; ` `}; ` ` `  `// Function to create and return a new node ` `static` `Node insert(``int` `data) ` `{ ` `    ``Node temp; ` `    ``temp = ``new` `Node(); ` `    ``temp.data = data; ` `    ``temp.next = ``null``; ` `    ``return` `temp; ` `} ` ` `  `// Function which returns the total number  ` `// of node present in the list ` `static` `int` `getTotalNodeCount(Node head) ` `{ ` `    ``int` `totalNodesCount = 0; ` `     `  `    ``while``(head != ``null``) ` `    ``{ ` `        ``totalNodesCount++; ` `        ``head = head.next; ` `    ``} ` `    ``return` `totalNodesCount; ` `} ` ` `  `static` `Node temp = ``null``; ` ` `  `// Function to modify the contents ` `// of the given linked lists ` `static` `void` `modifyContents(Node second_half)  ` `{ ` `    ``if` `(second_half == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` `     `  `    ``modifyContents(second_half.next); ` `     `  `    ``(temp).data = second_half.data - (temp).data; ` `    ``(temp) = (temp).next; ` `     `  `    ``return``; ` `} ` ` `  `// Wrapper function which calculates the starting  ` `// point for second half of the list ` `static` `Node modifyContentsWrapper(Node head) ` `{ ` `    ``// pointer to second half of list ` `    ``Node ptr = ``null``;  ` `    ``temp = ``null``;  ` `    ``int` `diff = 0;  ` `     `  `    ``// number of nodes in the list ` `    ``int` `length = 0;  ` `     `  `    ``if` `(head == ``null``) ` `    ``{ ` `        ``return` `null``; ` `    ``} ` `    ``length = getTotalNodeCount(head); ` `     `  `    ``// If link list has odd number of nodes,  ` `    ``// then pointer for second half starts  ` `    ``// from (length of link list + 1).  ` `    ``// Say for an example, for the list 10.4.5.3.6  ` `    ``// pointer should start from 3. ` `    ``// If list has even number of nodes,  ` `    ``// 10.4.5.9.6.8, pointer starts from 9. ` `    ``diff = (length % 2 == 0 ?  ` `           ``(length / 2) : (length / 2) + 1); ` `     `  `    ``ptr = head; ` ` `  `    ``while``(diff-->0) ` `        ``ptr = ptr.next; ` ` `  `    ``temp = head; ` ` `  `    ``modifyContents(ptr); ` ` `  `    ``return` `head; ` `} ` ` `  `// Function to print the contents ` `// of the linked list ` `static` `void` `print(Node nod) ` `{ ` `    ``if` `(nod == ``null``) ` `    ``{ ` `        ``return``; ` `    ``} ` `     `  `    ``Console.Write(nod.data); ` `     `  `    ``if` `(nod.next != ``null``) ` `        ``Console.Write(``" -> "``); ` `     `  `    ``print(nod.next); ` `} ` ` `  `// Driver code ` `public` `static` `void` `Main(String []args) ` `{ ` `    ``Node head = insert(2); ` `    ``head.next = insert(9); ` `    ``head.next.next = insert(8); ` `    ``head.next.next.next = insert(12); ` `    ``head.next.next.next.next = insert(7); ` `    ``head.next.next.next.next.next = insert(10); ` `     `  `    ``// Modify the linked list ` `    ``head = modifyContentsWrapper(head); ` ` `  `    ``// Print the modified linked list ` `    ``print(head); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:
```8 -> -2 -> 4 -> 12 -> 7 -> 10
```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : kani_26, andrew1234, princiraj1992

Article Tags :
Practice Tags :