Skip to content
Related Articles

Related Articles

Improve Article

Divide the given linked list in two lists of size ratio p:q

  • Last Updated : 04 Jun, 2021

Given a linked list and two integers p and q, the task is to divide the linked list in the ratio p:q i.e. the first list contains first p nodes from the original list and the second list contains the rest of the q nodes. If the original list cannot be split in the given ratio then print -1.
Examples: 
 

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 
 

 

Approach: First find the length of the linked list. If the total ratio sum exceeds the actual length then dividing the list is not possible so print -1. If it is possible to divide the list then simply traverse the list up to length p and break it into the ratio p:q. Next node will be the head of the second list then print both the lists.
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include<bits/stdc++.h>
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




<script>
 
// 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.
</script>
Output: 



1 3 
5 6 7 2

 

Time Complexity: 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.  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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :