# 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

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++

 `// 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

 `// 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

 `# 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#

 `// 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`

## Javascript

 ``

Output

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

Complexity Analysis:

• Time Complexity: O(N), as we are using recursive calls to traverse N times, where N is the number of Nodes in the linked list.
• Auxiliary Space: O(1), as we are not using any extra space.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next