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

• Last Updated : 23 Nov, 2021

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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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.
The difference between squares of 5 and 2 forms the second node with value 21.
The 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.
The difference between squares of 9 and 3 forms the second node with value 72.
The difference between squares of 8 and 4 forms the third node with value 48.
The 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 node’s value in it, and sort the deque. Now, access the largest and smallest values from both ends. Below are the steps:

• Create a deque and insert all values into the deque.
• Sort the deque to get the largest node value and smallest node value in constant time.
• Create another linked list having the value difference of square’s of the largest and the smallest values 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++

 `// 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;``        ``}` `        ``// Otherwise, 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

 `// 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;``    ``}` `    ``// Otherwise, 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

 `# 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 print the Linked List``def` `printt(head):` `    ``curr ``=` `head` `    ``# Iterate until curr``    ``# is None``    ``while` `(curr):` `        ``# Print the 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)` `    ``# Print the new LL formed``    ``printt(temp)` `# This code is contributed by Mohit kumar 29`

## C#

 `// 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;``    ``}` `    ``// Otherwise, 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`

## Javascript

 ``
Output:
`35 21 7`

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

My Personal Notes arrow_drop_up