Given a linked list, in which each node contains an integer value, Between every adjacent pair of nodes insert a new node with a value equal to the greatest common divisor of them.

Examples:

Input: Linked List = 30 -> 6 -> 14 -> 3 -> NULL
Output: 30 -> 6 -> 6 -> 2 -> 14 -> 1 -> 3 -> NULL

Explanation:

• We insert the greatest common divisor of 30 and 6 = 6 between the 1st and the 2nd node.
• We insert the greatest common divisor of 6 and 14 = 2 between the 2nd and the 3rd node.
• We insert the greatest common divisor of 14 and 3 = 1 between the 3rd and the 4th node.

There are no more adjacent nodes, so we return the linked list.

Input: Linked List = 3 -> NULL
Output: 3 -> NULL
Explanation: There are no pairs of adjacent nodes, so we return the initial linked list as it is.

Approach:

We can solve this problem by traversing the linked list and keeping track of previous node and each step insert a new node which represents the GCD of current node and previous node.

Step-by-step algorithm:

• Check for Base Cases: If the linked list is empty or has only one node, return the list as it is.
• Initialize Variables:
  • prev is initialized to null as there’s no previous node initially.
  • curr is initialized to the head of the list.
  • n is initialized to the next node after curr.
• Iterate Through the List:
  • Use a while loop to iterate over the list until n becomes null.
• Within the loop:
  • Calculate the GCD of curr.data and n.data using the gcd method.
  • Create a new ListNode called temp with the GCD value.
  • Set prev.next to point to temp, linking the previous node to the new node containing the GCD.
  • Set temp.next to point to curr, linking the new node to the next node in the original list.
  • Update prev, curr, and n to move one step forward in the list.
• Return the Modified List: After the loop, return the head of the modified list.

Below is the implementation of the above algorithm:

#include <iostream>
using namespace std;

// Structure of a Node
struct ListNode {
    int data;
    ListNode* next;
    ListNode(int data) : data(data), next(nullptr) {}
};

// Euclidean function for GCD Calculation
int gcd(int x, int y) {
    if (y == 0)
        return x;
    return gcd(y, x % y);
}

// Insertion of GCD
ListNode* insertGreatestCommonDivisors(ListNode* head) {
    // Base Case
    if (head == nullptr || head->next == nullptr)
        return head;

    // Variable initialization
    ListNode* prev = nullptr;
    ListNode* curr = head;
    ListNode* n = curr->next;

    // Traversing linked list and simultaneously
    // inserting new node having gcd of both nodes
    while (n != nullptr) {
        int val = gcd(curr->data, n->data);
        ListNode* temp = new ListNode(val);
        prev = curr;
        curr = n;
        n = n->next;
        temp->next = curr;
        prev->next = temp;
    }
    return head;
}

// Driver Function
int main() {
    // Creating a linked list
    ListNode* head = new ListNode(30);
    head->next = new ListNode(6);
    head->next->next = new ListNode(14);
    head->next->next->next = new ListNode(3);

    // Function call for operation
    ListNode* ans = insertGreatestCommonDivisors(head);
    ListNode* temp = ans;

    // Traversing the final linked list
    while (temp != nullptr) {
        cout << temp->data << " ";
        temp = temp->next;
    }
    return 0;
}
// This code is contributed by shivamgupta0987654321

/*package whatever //do not write package name here */

import java.io.*;

class GFG {

    // Structure of a Node
    public static class ListNode {
        int data;
        ListNode next;
        ListNode(int data) { this.data = data; }
    }

    // Euclidean function for GCD Calculation
    public static int gcd(int x, int y)
    {
        if (y == 0)
            return x;
        return gcd(y, x % y);
    }

    // Insertion of GCD
    public static ListNode
    insertGreatestCommonDivisors(ListNode head)
    {

        // Base Case
        if (head == null || head.next == null)
            return head;

        // Variable initialization
        ListNode prev = null;
        ListNode curr = head;
        ListNode n = curr.next;

        // Traversing linked list and simultaniously
        // inserting new node having gcd of both nodes
        while (n != null) {
            int val = gcd(curr.data, n.data);
            ListNode temp = new ListNode(val);
            prev = curr;
            curr = n;
            n = n.next;
            temp.next = curr;
            prev.next = temp;
        }
        return head;
    }

    // Driver Function
    public static void main(String[] args)
    {

        // Creating a linked list
        ListNode head = new ListNode(30);
        head.next = new ListNode(6);
        head.next.next = new ListNode(14);
        head.next.next.next = new ListNode(3);

        // Function call for operation
        ListNode ans = insertGreatestCommonDivisors(head);
        ListNode temp = ans;

        // Traversing the final linked list
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
    }
}

class ListNode:
    def __init__(self, data):
        self.data = data
        self.next = None

def gcd(x, y):
    while y != 0:
        x, y = y, x % y
    return x

def insertGreatestCommonDivisors(head):
    if head is None or head.next is None:
        return head

    prev = None
    curr = head
    n = curr.next

    while n is not None:
        val = gcd(curr.data, n.data)
        temp = ListNode(val)
        prev = curr
        curr = n
        n = n.next
        temp.next = curr
        prev.next = temp

    return head

def printLinkedList(head):
    temp = head
    while temp is not None:
        print(temp.data, end=" ")
        temp = temp.next

# Creating the linked list
head = ListNode(30)
head.next = ListNode(6)
head.next.next = ListNode(14)
head.next.next.next = ListNode(3)

# Function call for operation
ans = insertGreatestCommonDivisors(head)

# Printing the final linked list
printLinkedList(ans)

// Structure of a Node
class ListNode {
    constructor(data) {
        this.data = data;
        this.next = null;
    }
}

// Euclidean function for GCD Calculation
function gcd(x, y) {
    if (y === 0)
        return x;
    return gcd(y, x % y);
}

// Insertion of GCD
function insertGreatestCommonDivisors(head) {
    // Base Case
    if (head === null || head.next === null)
        return head;

    // Variable initialization
    let prev = null;
    let curr = head;
    let n = curr.next;

    // Traversing linked list and simultaneously
    // inserting new node having gcd of both nodes
    while (n !== null) {
        let val = gcd(curr.data, n.data);
        let temp = new ListNode(val);
        prev = curr;
        curr = n;
        n = n.next;
        temp.next = curr;
        prev.next = temp;
    }
    return head;
}

// Driver Function
function main() {
    // Creating a linked list
    let head = new ListNode(30);
    head.next = new ListNode(6);
    head.next.next = new ListNode(14);
    head.next.next.next = new ListNode(3);

    // Function call for operation
    let ans = insertGreatestCommonDivisors(head);
    let temp = ans;

    // Collecting output in a string
    let output = "";
    while (temp !== null) {
        output += temp.data + " ";
        temp = temp.next;
    }

    // Printing the output in a single line
    console.log(output.trim());
}

// Call the main function to execute
main();

30 6 6 2 14 1 3 

Time Complexity: O(nlog(x)) , where n is number of nodes in linked list and x is the maximum value of any node.
Auxiliary Space Complexity:– O(1).