# Modify contents of Linked List using C++ program

Modifying a Linked List: In this article, we are going to learn how to modify the content of a linked list using C++ program?
Submitted by Souvik Saha, on May 06, 2019

Problem statement:

Given a linked list, you modified that linked list in such a way that the elements of the first half of that linked list are the difference of the first node to the last node and next node is the difference of the second node to the second last node and goes on.

Example:

```    Input:
4 → 5 → 9 → 3 → 8 → 1 → 2 → 5
Output:
-1 → 3 → 8 → -5 → 8 → 1 → 2 → 5

Input:
6 → 5 → 4 → 9 → 1 → 2 → 7
Output:
-1 → 3 → 3 → 9 → 1 → 2 → 7
```

Algorithm:

To solve the problem we can follow this algorithm:

1. First, we find the midpoint of that linked list and take a copy of that.
2. Then we divide that linked list from the middle point.
3. Then reverse the second part of that linked list.
4. Then calculate the difference of the first node of the two linked list and put the value to the original linked list.
5. Continue to find the difference until we go to the last node of the second element.

C++ implementation:

```#include <bits/stdc++.h>

using namespace std;

struct node {
int data;
node* next;
};

void print(node*);

//Create a new node
struct node* create_node(int x)
{
struct node* temp = new node;
temp -> data = x;
temp -> next = NULL;
return temp;
}

//Enter the node into the linked list
{
struct node* store = create_node(x);
return;
}
while (temp -> next) {
temp = temp -> next;
}
temp -> next = store;
}

void split_list(node* head, node** a, node** b)
{
struct node* fast = head -> next;
while (fast != NULL && fast -> next != NULL) {
slow = slow -> next;
fast = fast -> next -> next;
}
struct node* temp = slow -> next;
slow -> next = NULL;
*b = temp;
}

struct node* reverse(node* b)
{
struct node* curr = b;
struct node* next = NULL;
struct node* prev = NULL;
while (curr != NULL) {
next = curr -> next;
curr -> next = prev;
prev = curr;
curr = next;
}
return prev;
}

void merge(node* a, node* b, node** c)
{
struct node* temp = a;
*c = create_node(0);
struct node* curr = *c;
while (temp && b) {
curr -> next = create_node(temp -> data - b -> data);
b = b -> next;
temp = temp -> next;
curr = curr -> next;
//cout<<curr->data<<" ";
}
if (b != NULL) {
curr -> next = b;
curr = curr -> next;
}
curr -> next = reverse(a);
*c = (*c) -> next;
}

{
struct node* a;
struct node* b;
struct node* c;
struct node* temp = reverse(b);
merge(temp, a, &c);
return c;
}

//Print the list
{
while (temp) {
cout << temp -> data << " ";
temp = temp -> next;
}
}

int main()
{
struct node* l = NULL;
push(&l, 1);
push(&l, 2);
push(&l, 3);
push(&l, 4);
push(&l, 5);
push(&l, 6);
cout << "Before the modify operation" << endl;
print(l);
l = modifyTheList(l);
cout << "\nAfter the modify operation" << endl;
print(l);

return 0;
}
```

Output

```Before the modify operation
1 2 3 4 5 6
After the modify operation
5 3 1 4 5 6
```

Languages: » C » C++ » C++ STL » Java » Data Structure » C#.Net » Android » Kotlin » SQL
Web Technologies: » PHP » Python » JavaScript » CSS » Ajax » Node.js » Web programming/HTML
Solved programs: » C » C++ » DS » Java » C#
Aptitude que. & ans.: » C » C++ » Java » DBMS
Interview que. & ans.: » C » Embedded C » Java » SEO » HR
CS Subjects: » CS Basics » O.S. » Networks » DBMS » Embedded Systems » Cloud Computing
» Machine learning » CS Organizations » Linux » DOS
More: » Articles » Puzzles » News/Updates