 Open in App
Not now

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

• Last Updated : 11 Oct, 2022

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.
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 -> 24
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 24.
Therefore, the formed LL is 96 -> 72 -> 48 -> 24.

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