Insert Greatest Common Divisors in Linked List

Insert Greatest Common Divisors in Linked List - Problem

You're given the head of a linked list where each node contains an integer value. Your task is to enhance this linked list by inserting new nodes between every pair of adjacent nodes.

Each new node should contain the Greatest Common Divisor (GCD) of the two adjacent nodes it sits between. The GCD is the largest positive integer that divides both numbers evenly.

Goal: Return the modified linked list after all GCD insertions.

Example: If you have nodes with values [18, 6, 10, 3], you'll insert GCD nodes to get [18, 6, 6, 2, 10, 1, 3] because:

GCD(18, 6) = 6
GCD(6, 10) = 2
GCD(10, 3) = 1

Input & Output

example_1.py — Basic case

$ Input: head = [18, 6, 10, 3]

› Output: [18, 6, 6, 2, 10, 1, 3]

💡 Note: GCD(18,6)=6, GCD(6,10)=2, GCD(10,3)=1. Insert these values between respective pairs.

example_2.py — Two nodes

$ Input: head = [7]

› Output: [7]

💡 Note: Only one node exists, so no adjacent pairs to insert GCD between. Return original list.

example_3.py — Same values

$ Input: head = [12, 12, 12]

› Output: [12, 12, 12, 12, 12]

💡 Note: GCD(12,12)=12 for both pairs. Insert 12 between each adjacent pair of 12s.

Constraints

The number of nodes in the list is in the range [1, 5000]
1 ≤ Node.val ≤ 1000
All node values are positive integers

Visualization

Tap to expand

Understanding the Visualization

Start Journey

Begin at the first city (head node) and prepare to visit adjacent city pairs

Calculate Toll

For each pair of cities, use the Euclidean algorithm to find their GCD efficiently

Build Bridge

Construct a toll bridge (new node) between the cities with the calculated GCD value

Continue Path

Move to the next original city, skipping the newly built bridge, and repeat the process

Key Takeaway

🎯 Key Insight: The Euclidean algorithm makes GCD calculation extremely efficient, allowing us to solve this linked list problem optimally in a single pass while maintaining the list structure.

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses the Euclidean algorithm to efficiently calculate GCD in O(log min(a,b)) time while traversing the linked list once. We insert new nodes with GCD values between each adjacent pair, achieving O(n * log(min values)) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Optimized with Euclidean Algorithm	O(n * log(min(a,b)))	O(1)	Use efficient Euclidean algorithm for GCD calculation

Optimized with Euclidean Algorithm — Algorithm Steps

Start from the head of the linked list
For each node with a next node, calculate GCD using Euclidean algorithm
Create a new node with the calculated GCD value
Insert the new node between the current node and its next node
Move to the next original node (skip the inserted GCD node)
Repeat until all adjacent pairs are processed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with current pointer at head

Calculate GCD

Use Euclidean algorithm: gcd(18,6) → gcd(6,0) = 6

Insert node

Create new node with GCD value and insert between pair

Advance

Move current to next original node, skipping inserted GCD node

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

// Definition for singly-linked list.
struct ListNode {
    int val;
    struct ListNode *next;
};

int gcd(int a, int b) {
    while (b != 0) {
        int temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

struct ListNode* insertGreatestCommonDivisors(struct ListNode* head) {
    if (!head || !head->next) {
        return head;
    }
    
    struct ListNode* current = head;
    while (current && current->next) {
        int gcdVal = gcd(current->val, current->next->val);
        struct ListNode* newNode = (struct ListNode*)malloc(sizeof(struct ListNode));
        newNode->val = gcdVal;
        newNode->next = current->next;
        current->next = newNode;
        current = newNode->next;
    }
    
    return head;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * log(min(a,b)))

O(n) to traverse list, O(log min(a,b)) for each efficient GCD calculation

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for new nodes and variables

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimized with Euclidean Algorithm — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler