将给定的链表分成大小比例为 p:q 的两个列表

给定一个链表和两个整数p和q ，任务是以p:q的比例划分链表，即第一个列表包含来自原始列表的前p 个节点，第二个列表包含其余的q 个节点。如果原始列表不能以给定的比例拆分，则打印-1 。
例子：

Input: 1 -> 3 -> 5 -> 6 -> 7 -> 2 -> NULL 
p = 2, q = 4 
Output: 
1 3 
5 6 7 2
Input: 1 -> 2 -> 4 -> 9 -> NULL 
p = 3, q = 2 
Output: -1 
 

方法：先求链表的长度。如果总比率和超过实际长度，则无法划分列表，因此打印-1 。如果可以划分列表，则只需遍历列表直至长度为p并将其分解为比率p:q 。下一个节点将是第二个列表的头部，然后打印两个列表。
下面是上述方法的实现：

C++

// C++ implementation of the approach
#include
using namespace std;
 
struct Node
{
    int data;
    Node *next;
 
    Node(int data)
    {
        this->data = data;
        this->next = NULL;
    }
};
 
void printList(Node *);
 
// Function to split the given linked list
// into ratio of p and q
void splitAndPrint(Node *head, int p, int q)
{
  int n = 0;
  Node *temp;
  temp = head;
 
  // Find the length of the list
  while (temp != NULL)
  {
    n += 1;
    temp = temp->next;
  }
 
  // If ration exceeds the actual length
  if (p + q > n)
  {
    cout << "-1" << endl;
    return;
  }
  temp = head;
  while (p > 1)
  {
    temp = temp->next;
    p -= 1;
  }
 
  // second head node after splitting
  Node *head2 = temp->next;
  temp->next = NULL;
 
  // Print first linked list
  printList(head);
  cout << endl;
 
  // Print second linked list
  printList(head2);
}
 
// Function to print the nodes
// of the linked list
void printList(Node* head)
{
  if (head == NULL)
    return;
  cout << head->data << " ";
  printList(head->next);
}
 
// Driver code
int main()
{
  Node* head = new Node(1);
  head->next = new Node(3);
  head->next->next = new Node(5);
  head->next->next->next = new Node(6);
  head->next->next->next->next = new Node(7);
  head->next->next->next->next->next = new Node(2);
 
  int p = 2, q = 4;
  splitAndPrint(head, p, q);
}
 
// This code is contributed by rutvik_56.

Java

// Java implementation of the approach
class GFG
{
     
// Node
static class Node
{
    int data;
    Node next;
    Node(int data)
    {
        this.data = data;
    }
}
 
// Function to split the given linked list
// into ratio of p and q
static void splitAndPrint(Node head,int p,int q)
{
    int n = 0;
    Node temp;
    temp = head;
     
    // Find the length of the list
    while(temp!=null)
    {
        n += 1;
        temp = temp.next;
    }
     
    // If ration exceeds the actual length
    if (p + q > n)
    {
        System.out.println("-1");
        return;
    }
    temp = head;
    while(p > 1)
    {
        temp = temp.next;
        p-= 1;
    }
     
    // second head node after splitting
    Node head2 = temp.next;
    temp.next = null;
     
    // Print first linked list
    printList(head);
    System.out.println();
     
    // Print second linked list
    printList(head2);
}
 
// Function to print the nodes
// of the linked list
static void printList(Node head)
{
    if( head == null)
        return;
    System.out.print(head.data+" , ");
    printList(head.next);
}
 
// Driver code
public static void main(String args[])
{
    Node head = new Node(1);
    head.next = new Node(3);
    head.next.next = new Node(5);
    head.next.next.next = new Node(6);
    head.next.next.next.next = new Node(7);
    head.next.next.next.next.next = new Node(2);
     
    int p =2,q= 4;
    splitAndPrint(head, p, q);
}
}
 
// This code is contributed by Arnab Kundu

Python

# Python3 implementation of the approach
 
# Linked List node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
# Function to split the given linked list
# into ratio of p and q
def splitAndPrint(head, p, q):
    n, temp = 0, head
     
    # Find the length of the list
    while(temp):
        n += 1
        temp = temp.next
     
    # If ration exceeds the actual length
    if p + q>n:
        print("-1")
        return
 
    temp = head
    while(p>1):
        temp = temp.next
        p-= 1
     
    # second head node after splitting
    head2 = temp.next
    temp.next = None
     
    # Print first linked list
    printList(head)
    print()
     
    # Print second linked list
    printList(head2)
 
# Function to print the nodes
# of the linked list
def printList(head):
    if not head:
        return
    print("{} ".format(head.data), end ="")
    printList(head.next)
 
# Driver code
head = Node(1)
head.next = Node(3)
head.next.next = Node(5)
head.next.next.next = Node(6)
head.next.next.next.next = Node(7)
head.next.next.next.next.next = Node(2)
 
p, q = 2, 4
splitAndPrint(head, p, q)

C#

// C# implementation of the approach
using System;
 
class GFG
{
     
public class Node
{
    public int data;
    public Node next;
    public Node(int data)
    {
        this.data = data;
    }
}
 
// Function to split the given linked list
// into ratio of p and q
static void splitAndPrint(Node head,int p,int q)
{
    int n = 0;
    Node temp;
    temp = head;
     
    // Find the length of the list
    while(temp != null)
    {
        n += 1;
        temp = temp.next;
    }
     
    // If ration exceeds the actual length
    if (p + q > n)
    {
        Console.WriteLine("-1");
        return;
    }
    temp = head;
    while(p > 1)
    {
        temp = temp.next;
        p-= 1;
    }
     
    // second head node after splitting
    Node head2 = temp.next;
    temp.next = null;
     
    // Print first linked list
    printList(head);
    Console.WriteLine();
     
    // Print second linked list
    printList(head2);
}
 
// Function to print the nodes
// of the linked list
static void printList(Node head)
{
    if( head == null)
        return;
    Console.Write(head.data+" ");
    printList(head.next);
}
 
// Driver code
public static void Main(String []args)
{
    Node head = new Node(1);
    head.next = new Node(3);
    head.next.next = new Node(5);
    head.next.next.next = new Node(6);
    head.next.next.next.next = new Node(7);
    head.next.next.next.next.next = new Node(2);
     
    int p = 2, q = 4;
    splitAndPrint(head, p, q);
}
}
 
/* This code contributed by PrinciRaj1992 */

Javascript

 
// Javascript implementation of the approach
 
// Node
class Node
{
        constructor(data)
        {
            this.data = data;
         }
}
 
// Function to split the given linked list
// into ratio of p and q
function splitAndPrint( head, p, q)
{
    var n = 0;
    var temp;
    temp = head;
     
    // Find the length of the list
    while(temp!=null)
    {
        n += 1;
        temp = temp.next;
    }
     
    // If ration exceeds the actual length
    if (p + q > n)
    {
        document.write("-1");
        return;
    }
    temp = head;
    while(p > 1)
    {
        temp = temp.next;
        p-= 1;
    }
     
    // second head node after splitting
    var head2 = temp.next;
    temp.next = null;
     
    // Print first linked list
    printList(head);
    document.write("</br>");
     
    // Print second linked list
    printList(head2);
}
 
// Function to print the nodes
// of the linked list
function printList(head)
{
    if( head == null)
        return;
    document.write(head.data + "  ");
    printList(head.next);
}
 
    // Driver Code
    let head = new Node(1);
    head.next = new Node(3);
    head.next.next = new Node(5);
    head.next.next.next = new Node(6);
    head.next.next.next.next = new Node(7);
    head.next.next.next.next.next = new Node(2);
     
    let p = 2, q = 4;
    splitAndPrint(head, p, q);
 
// This code is contributed by jana_sayantan.

输出：

1 3 
5 6 7 2

时间复杂度： O(N)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。