# Modify contents of Linked List using C++ program

Modify contents of Linked List: In this tutorial, we will learn how to modify the contents of linked lists using the C++ program? By Souvik Saha Last updated : August 02, 2023

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

The following are the steps/algorithm to Modify contents of Linked List:

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++ program to modify contents of Linked List

```#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
void push(node** head, int x)
{
struct node* store = create_node(x);
if (*head == NULL) {
*head = store;
return;
}
struct node* temp = *head;
while (temp -> next) {
temp = temp -> next;
}
temp -> next = store;
}

void split_list(node* head, node** a, node** b)
{
struct node* fast = head -> next;
struct node* slow = head;
while (fast != NULL && fast -> next != NULL) {
slow = slow -> next;
fast = fast -> next -> next;
}
struct node* temp = slow -> next;
slow -> next = NULL;
*a = head;
*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* modifyTheList(struct node* head)
{
//add code here.
struct node* a;
struct node* b;
struct node* c;
split_list(head, &a, &b);
struct node* temp = reverse(b);
merge(temp, a, &c);
return c;
}

//Print the list
void print(node* head)
{
struct node* temp = head;
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
```

Comments and Discussions!

Student's Section
Subscribe

Copyright © 2024 www.includehelp.com. All rights reserved.