📜  生成链接列表,该列表由给定链接列表中的节点对的平方的最大差值组成

📅  最后修改于: 2021-04-23 06:04:44             🧑  作者: Mango

给定一个节点数为偶数的链表,任务是生成一个新的链表,以使其包含的节点值平方的最大差值通过将每个节点包括在一对中而以降序排列。

例子:

方法:方法是找到一个节点的最大值,并始终在最大和最小节点值之间求差。所以创建一个双端队列 并在其中插入所有节点的值,并对双端队列进行排序。现在,从两端访问最大值和最小值。步骤如下:

  • 创建双端队列,并将所有节点值插入双端队列。
  • 对双端队列进行排序,以在恒定时间内获得最大的节点值和最小的节点值。
  • 创建另一个链表,其值分别与双端队列的背面和正面的平方差的最大值和最小值成正比。
  • 每次迭代后,从双端队列弹出最小和最大值。
  • 完成上述步骤后,打印形成的新链表的节点。

下面是上述方法的实现:

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 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
// 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
# 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 v =
       new List();    
  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


输出:
35 21 7

时间复杂度: O(N * log N)
辅助空间: O(N)