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

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
 
#include <bits/stdc++.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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<Integer> 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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[0];
    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

chevron_right


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.




My Personal Notes arrow_drop_up

Recommended Posts:


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.