# Generate Linked List consisting of maximum difference of squares of pairs of nodes from given Linked List

Given a Linked List of even number of nodes, the task is to generate a new Linked List such that it contains the maximum difference of squares of node values in decreasing order by including each node in a single pair.

Examples:

Input: 1 -> 6 -> 4 -> 3 -> 5 ->2
Output: 35 -> 21 -> 7
Explanation:
The difference between squares of 6 and 1 forms the first node with value 35.
Difference between squares of 5 and 2 forms the second node with value 21.
Difference between squares of 4 and 3 forms the third node with value 7.
Therefore, the formed LL is 35 -> 21 -> 7.

Input: 2 -> 4 -> 5 -> 3 -> 7 -> 8 -> 9 -> 10
Output: 96 -> 72 -> 48 -> 10
Explanation:
The difference between squares of 10 and 2 forms the first node with value 96.
Difference between squares of 9 and 3 forms the second node with value 72.
Difference between squares of 8 and 4 forms the third node with value 48.
Difference between squares of 7 and 5 forms the fourth node with value 10.
Therefore, the formed LL is 96 -> 72 -> 48 -> 10.

Approach: The approach is to find the maximum value of a node and always make the difference between the largest and the smallest node value. So create a deque and insert all nodes value in it, and sort the deque. Now, access the largest and smallest values from both the ends. Below are the steps:

• Create a deque and insert all nodes value in the deque.
• Sort the deque to get the largest node value and smallest node value in constant time.
• Create another linked list having value difference of square’s of the largest and the smallest value from the back and the front of the deque respectively.
• After each iteration pop both the smallest and largest value from the deque.
• After the above steps, print the nodes of the new Linked List formed.

Below is the implementation of the above approach:

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Linked list node` `struct` `Node {` `    ``int` `data;` `    ``struct` `Node* next;` `};`   `// Function to push into 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;` `    ``new_node->next = (*head_ref);`   `    ``// Move the head to point` `    ``// to the new node` `    ``(*head_ref) = new_node;` `}`   `// Function to print the Linked List` `void` `print(``struct` `Node* head)` `{` `    ``Node* curr = head;`   `    ``// Iterate until curr is NULL` `    ``while` `(curr) {`   `        ``// Print the data` `        ``cout << curr->data << ``" "``;`   `        ``// Move to next` `        ``curr = curr->next;` `    ``}` `}`   `// Function to create a new Node of` `// the Linked List` `struct` `Node* newNode(``int` `x)` `{` `    ``struct` `Node* temp` `        ``= (``struct` `Node*)``malloc``(` `            ``sizeof``(``struct` `Node));`   `    ``temp->data = x;` `    ``temp->next = NULL;`   `    ``// Return the node created` `    ``return` `temp;` `}`   `// Function used to re-order list` `struct` `Node* reorder(Node* head)` `{` `    ``// Stores the node of LL` `    ``deque<``int``> v;` `    ``Node* curr = head;`   `    ``// Traverse the LL` `    ``while` `(curr) {` `        ``v.push_back(curr->data);` `        ``curr = curr->next;` `    ``}`   `    ``// Sort the deque` `    ``sort(v.begin(), v.end());`   `    ``// Node head1 stores the` `    ``// head of the new Linked List` `    ``Node* head1 = NULL;` `    ``Node* prev = NULL;`   `    ``// Size of new LL` `    ``int` `x = v.size() / 2;`   `    ``// Loop to make new LL` `    ``while` `(x--) {` `        ``int` `a = v.front();` `        ``int` `b = v.back();`   `        ``// Difference of squares of` `        ``// largest and smallest value` `        ``int` `ans = ``pow``(b, 2) - ``pow``(a, 2);`   `        ``// Create node with value ans` `        ``struct` `Node* temp = newNode(ans);` `        ``if` `(head1 == NULL) {` `            ``head1 = temp;` `            ``prev = temp;` `        ``}`   `        ``// Otherwsie, update prev` `        ``else` `{` `            ``prev->next = temp;` `            ``prev = temp;` `        ``}`   `        ``// Pop the front and back node` `        ``v.pop_back();` `        ``v.pop_front();` `    ``}`   `    ``// Return head of the new LL` `    ``return` `head1;` `}`   `// Driver Code` `int` `main()` `{` `    ``struct` `Node* head = NULL;`   `    ``// Given Linked ist` `    ``push(&head, 6);` `    ``push(&head, 5);` `    ``push(&head, 4);` `    ``push(&head, 3);` `    ``push(&head, 2);` `    ``push(&head, 1);`   `    ``// Function Call` `    ``Node* temp = reorder(head);`   `    ``// Print the new LL formed` `    ``print(temp);`   `    ``return` `0;` `}`

 `// Java program for the ` `// above approach` `import` `java.util.*;` `class` `GFG{`   `// Linked list node` `static` `class` `Node ` `{` `  ``int` `data;` `  ``Node next;` `};`   `static` `Node head ;`   `// Function to push ` `// into Linked List` `static` `void` `push(``int` `new_data)` `{` `  ``// Allocate node` `  ``Node new_node = ``new` `Node();`   `  ``// Put in the data` `  ``new_node.data = new_data;` `  ``new_node.next = head;`   `  ``// Move the head to point` `  ``// to the new node` `  ``head = new_node;` `}`   `// Function to print the` `// Linked List` `static` `void` `print(Node head)` `{` `  ``Node curr = head;`   `  ``// Iterate until curr ` `  ``// is null` `  ``while` `(curr != ``null``) ` `  ``{` `    ``// Print the data` `    ``System.out.print(curr.data + ``" "``);`   `    ``// Move to next` `    ``curr = curr.next;` `  ``}` `}`   `// Function to create a ` `// new Node of the Linked List` `static` `Node newNode(``int` `x)` `{` `  ``Node temp = ``new` `Node();` `  ``temp.data = x;` `  ``temp.next = ``null``;`   `  ``// Return the node ` `  ``// created` `  ``return` `temp;` `}`   `// Function used to re-order ` `// list` `static` `Node reorder(Node head)` `{` `  ``// Stores the node of LL` `  ``Deque v =` `        ``new` `LinkedList<>();` `  ``Node curr = head;`   `  ``// Traverse the LL` `  ``while` `(curr != ``null``) ` `  ``{` `    ``v.add(curr.data);` `    ``curr = curr.next;` `  ``}`   `  ``// Sort the deque` `  ``// Collections.sort(v);`   `  ``// Node head1 stores the` `  ``// head of the new Linked` `  ``// List` `  ``Node head1 = ``null``;` `  ``Node prev = ``null``;`   `  ``// Size of new LL` `  ``int` `x = v.size() / ``2``;`   `  ``// Loop to make new LL` `  ``while` `((x--) > ``0``) ` `  ``{` `    ``int` `a = v.peek();` `    ``int` `b = v.getLast();`   `    ``// Difference of squares of` `    ``// largest and smallest value` `    ``int` `ans = (``int``)(Math.pow(b, ``2``) - ` `                    ``Math.pow(a, ``2``));`   `    ``// Create node with value ans` `    ``Node temp = newNode(ans);` `    ``if` `(head1 == ``null``) ` `    ``{` `      ``head1 = temp;` `      ``prev = temp;` `    ``}`   `    ``// Otherwsie, update prev` `    ``else` `    ``{` `      ``prev.next = temp;` `      ``prev = temp;` `    ``}`   `    ``// Pop the front and` `    ``// back node` `    ``v.removeFirst();` `    ``v.removeLast();` `  ``}`   `  ``// Return head of the ` `  ``// new LL` `  ``return` `head1;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `  ``head = ``null``;`   `  ``// Given Linked ist` `  ``push(``6``);` `  ``push(``5``);` `  ``push(``4``);` `  ``push(``3``);` `  ``push(``2``);` `  ``push(``1``);`   `  ``// Function Call` `  ``Node temp = reorder(head);`   `  ``// Print the new ` `  ``// LL formed` `  ``print(temp);` `}` `}`   `// This code is contributed by Amit Katiyar`

 `# Python3 program for the ` `# above approach` `from` `collections ``import` `deque`   `# Linked list node` `class` `Node:` `  `  `    ``def` `__init__(``self``, x):` `      `  `        ``self``.data ``=` `x` `        ``self``.``next` `=` `None`   `# Function to push into Linked List` `# Function to push into Linked List` `def` `push(head_ref, new_data):`   `    ``new_node ``=` `Node(new_data)` `    ``new_node.``next` `=` `head_ref` `    ``head_ref ``=` `new_node` `    ``return` `head_ref`   `# Function to prthe Linked List` `def` `printt(head):`   `    ``curr ``=` `head`   `    ``# Iterate until curr ` `    ``# is None` `    ``while` `(curr):`   `        ``# Prthe data` `        ``print``(curr.data,` `              ``end ``=` `" "``)`   `        ``# Move to next` `        ``curr ``=` `curr.``next`   `# Function used to re-order list` `# Function used to re-order list` `def` `reorder(head):` `  `  `    ``# Stores the node of LL` `    ``arr ``=` `[]` `    ``curr ``=` `head`   `    ``while` `curr:` `        ``arr.append(curr.data)` `        ``curr ``=` `curr.``next`   `    ``arr ``=` `sorted``(arr)`   `    ``# Sort the deque` `    ``v ``=` `deque()`   `    ``for` `i ``in` `arr:` `        ``v.append(i)`   `    ``# Node head1 stores the` `    ``# head of the new Linked List` `    ``head1 ``=` `None` `    ``prev ``=` `None`   `    ``x ``=` `len``(arr) ``/``/` `2`   `    ``while` `x:` `        ``a ``=` `v.popleft()` `        ``b ``=` `v.pop()`   `        ``# Difference of squares of` `        ``# largest and smallest value` `        ``ans ``=` `pow``(b, ``2``) ``-` `pow``(a, ``2``)`   `        ``temp ``=` `Node(ans)`   `        ``if` `head1 ``=``=` `None``:` `            ``head1 ``=` `temp` `            ``prev ``=` `temp` `        ``else``:` `            ``prev.``next` `=` `temp` `            ``prev ``=` `temp` `        ``x ``-``=` `1`   `    ``# Return head of the new LL` `    ``return` `head1`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `  `  `    ``head ``=` `None`   `    ``# Given Linked ist` `    ``head ``=` `push(head, ``6``)` `    ``head ``=` `push(head, ``5``)` `    ``head ``=` `push(head, ``4``)` `    ``head ``=` `push(head, ``3``)` `    ``head ``=` `push(head, ``2``)` `    ``head ``=` `push(head, ``1``)`   `    ``# Function Call` `    ``temp ``=` `reorder(head)`   `    ``# Prthe new LL formed` `    ``printt(temp)`   `# This code is contributed by Mohit kumar 29`

 `// C# program for the ` `// above approach` `using` `System;` `using` `System.Collections.Generic;` `class` `GFG{`   `// Linked list node` `public` `class` `Node ` `{` `  ``public` `int` `data;` `  ``public` `Node next;` `};`   `static` `Node head ;`   `// Function to push ` `// into Linked List` `static` `void` `push(``int` `new_data)` `{` `  ``// Allocate node` `  ``Node new_node = ``new` `Node();`   `  ``// Put in the data` `  ``new_node.data = new_data;` `  ``new_node.next = head;`   `  ``// Move the head to point` `  ``// to the new node` `  ``head = new_node;` `}`   `// Function to print the` `// Linked List` `static` `void` `print(Node head)` `{` `  ``Node curr = head;`   `  ``// Iterate until curr ` `  ``// is null` `  ``while` `(curr != ``null``) ` `  ``{` `    ``// Print the data` `    ``Console.Write(curr.data + ``" "``);`   `    ``// Move to next` `    ``curr = curr.next;` `  ``}` `}`   `// Function to create a ` `// new Node of the Linked List` `static` `Node newNode(``int` `x)` `{` `  ``Node temp = ``new` `Node();` `  ``temp.data = x;` `  ``temp.next = ``null``;`   `  ``// Return the node ` `  ``// created` `  ``return` `temp;` `}`   `// Function used to re-order ` `// list` `static` `Node reorder(Node head)` `{` `  ``// Stores the node of LL` `  ``List<``int``> v =` `       ``new` `List<``int``>();     ` `  ``Node curr = head;`   `  ``// Traverse the LL` `  ``while` `(curr != ``null``) ` `  ``{` `    ``v.Add(curr.data);` `    ``curr = curr.next;` `  ``}`   `  ``// Sort the deque` `  ``// Collections.sort(v);`   `  ``// Node head1 stores the` `  ``// head of the new Linked` `  ``// List` `  ``Node head1 = ``null``;` `  ``Node prev = ``null``;`   `  ``// Size of new LL` `  ``int` `x = v.Count / 2;`   `  ``// Loop to make new LL` `  ``while` `((x--) > 0) ` `  ``{` `    ``int` `a = v;` `    ``int` `b = v[v.Count-1];`   `    ``// Difference of squares of` `    ``// largest and smallest value` `    ``int` `ans = (``int``)(Math.Pow(b, 2) - ` `                    ``Math.Pow(a, 2));`   `    ``// Create node with value ans` `    ``Node temp = newNode(ans);` `    ``if` `(head1 == ``null``) ` `    ``{` `      ``head1 = temp;` `      ``prev = temp;` `    ``}`   `    ``// Otherwsie, update prev` `    ``else` `    ``{` `      ``prev.next = temp;` `      ``prev = temp;` `    ``}`   `    ``// Pop the front and` `    ``// back node` `    ``v.RemoveAt(0);` `    ``v.RemoveAt(v.Count - 1);` `  ``}`   `  ``// Return head of the ` `  ``// new LL` `  ``return` `head1;` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `  ``head = ``null``;`   `  ``// Given Linked ist` `  ``push(6);` `  ``push(5);` `  ``push(4);` `  ``push(3);` `  ``push(2);` `  ``push(1);`   `  ``// Function Call` `  ``Node temp = reorder(head);`   `  ``// Print the new ` `  ``// LL formed` `  ``print(temp);` `}` `}`   `// This code is contributed by gauravrajput1`

Output:
```35 21 7

```

Time Complexity: O(N*log N)
Auxiliary Space: O(N)

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.

Article Tags :