Add Two Numbers represented as Linked List using Recursion

Given two numbers represented as two lists, the task is to return the sum of two lists using recursion.

Note: There can be leading zeros in the input lists, but there should not be any leading zeros in the output list.

Examples:

Input: num1 = 4 -> 5, num2 = 3 -> 4 -> 5
Output: 3 -> 9 -> 0
Explanation: Sum of 45 and 345 is 390.
Add two numbers represented as Linked List
Input: num1 = 0 -> 0 -> 6 -> 3, num2 = 0 -> 7
Output: 7 -> 0
Explanation: Sum of 63 and 7 is 70.
Input: num1 = 1 -> 2 -> 3, num2 = 9 -> 9 -> 9
Output: 1 -> 1 -> 2 -> 2
Explanation: Sum of 123 and 999 is 1122.

Try It Yourself

Approach:

The idea is to use recursion to compute the sum. Reverse both the linked lists to start from the least significant digit. Now, traverse both the linked list recursively and in each recursive add the values of the current nodes and the carry from the previous step (initially, carry = 0). If there is a carry after the last nodes, append a new node with this carry. Finally, reverse the linked list to get the sum.

C++

// C++ code to add two linked list using recursion

#include <iostream>
using namespace std;

class Node {
  public:
    int data;
    Node *next;
    Node(int val) {
        data = val;
        next = nullptr;
    }
};

// Function to reverse a linked list
Node *reverse(Node *head) {
    Node *prev = nullptr;
    Node *curr = head;
    Node *next = nullptr;

    // Loop to reverse the linked list
    while (curr != nullptr) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

// Recursive function to add two numbers represented
// by linked lists
Node *addListRec(Node *num1, Node *num2, int &carry) {

    // Base case: If both lists are empty and no carry is left
    if (num1 == nullptr && num2 == nullptr && carry == 0) {
        return nullptr;
    }

    int sum = carry;

    // Add the value from the first list if it exists
    if (num1 != nullptr) {
        sum += num1->data;
        num1 = num1->next;
    }

    // Add the value from the second list if it exists
    if (num2 != nullptr) {
        sum += num2->data;
        num2 = num2->next;
    }

    carry = sum / 10;
    Node *result = new Node(sum % 10);

    // Recursively add remaining digits
    result->next = addListRec(num1, num2, carry);

    return result;
}

// function to trim leading zeros in linked list
Node* trimLeadingZeros(Node* head) {
	while (head != nullptr && head->data == 0) {
        head = head->next;
    }
    return head;
}

// function for adding two linked lists
Node *addTwoLists(Node *num1, Node *num2) {
	num1 = trimLeadingZeros(num1);
	num2 = trimLeadingZeros(num2);

    // Reverse both lists to start addition from 
    // the least significant digit
    num1 = reverse(num1);
    num2 = reverse(num2);

    int carry = 0;
    Node *result = addListRec(num1, num2, carry);

    // If there's any carry left after the addition,
    // create a new node for it
    if (carry != 0) {
        Node *newNode = new Node(carry);
        newNode->next = result;
        result = newNode;
    }

    // Reverse the result list to restore
    // the original order
    return reverse(result);
}

void printList(Node *head) {
    Node *curr = head;
	while (curr != nullptr) {
        cout << curr->data << " ";
        curr = curr->next;
    }
    cout << "\n";
}

int main() {
  
    // Creating first linked list: 1 -> 2 -> 3 
      // (represents 123)
    Node *num1 = new Node(1);
    num1->next = new Node(2);
    num1->next->next = new Node(3);

    // Creating second linked list: 9 -> 9 -> 9 
	// (represents 999)
    Node *num2 = new Node(9);
    num2->next = new Node(9);
    num2->next->next = new Node(9);

    Node *sum = addTwoLists(num1, num2);
    printList(sum);

    return 0;
}

// C code to add two linked list using recursion 

#include <stdio.h>

struct Node {
    int data;
    struct Node *next;
};

// Function to create a new node
struct Node* createNode(int val) {
    struct Node* newNode = 
      		(struct Node*)malloc(sizeof(struct Node));
    newNode->data = val;
    newNode->next = NULL;
    return newNode;
}

// Function to reverse a linked list
struct Node* reverse(struct Node* head) {
    struct Node* prev = NULL;
    struct Node* curr = head;
    struct Node* next = NULL;

    // Loop to reverse the linked list
    while (curr != NULL) {
        next = curr->next;
        curr->next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

// function to trim leading zeros in linked list
struct Node* trimLeadingZeros(struct Node* head) {
    while (head->next != NULL && head->data == 0)
        head = head->next;
    return head;
}

// Recursive function to add two numbers represented by linked lists
struct Node* addListRec(struct Node* num1, 
                        struct Node* num2, int* carry) {
    
  	// Base case: If both lists are empty and no carry is left
    if (num1 == NULL && num2 == NULL && *carry == 0) {
        return NULL;
    }

    int sum = *carry;

    // Add the value from the first list if it exists
    if (num1 != NULL) {
        sum += num1->data;
        num1 = num1->next;
    }

    // Add the value from the second list if it exists
    if (num2 != NULL) {
        sum += num2->data;
        num2 = num2->next;
    }

    *carry = sum / 10;
    struct Node* result = createNode(sum % 10);

    // Recursively add remaining digits
    result->next = addListRec(num1, num2, carry);

    return result;
}

// Function for adding two linked lists
struct Node* addTwoLists(struct Node* num1, struct Node* num2) {
	num1 = trimLeadingZeros(num1);
    num2 = trimLeadingZeros(num2);
  
  	// Reverse both lists to start addition from the 
  	// least significant digit
    num1 = reverse(num1);
    num2 = reverse(num2);

    int carry = 0;
    struct Node* result = addListRec(num1, num2, &carry);

    // If there's any carry left after the addition,
  	// create a new node for it
    if (carry != 0) {
        struct Node* newNode = createNode(carry);
        newNode->next = result;
        result = newNode;
    }

    // Reverse the result list to restore the original order
    return reverse(result);
}

// Function to print a linked list
void printList(struct Node* head) {
    struct Node* curr = head;
    while (curr != NULL) {
        printf("%d ", curr->data);
        curr = curr->next;
    }
    printf("\n");
}

int main() {
  	
    // Creating first linked list: 1 -> 2 -> 3 (represents 123)
    struct Node* num1 = createNode(1);
    num1->next = createNode(2);
    num1->next->next = createNode(3);

    // Creating second linked list: 9 -> 9 -> 9 (represents 999)
    struct Node* num2 = createNode(9);
    num2->next = createNode(9);
    num2->next->next = createNode(9);

    struct Node* sum = addTwoLists(num1, num2);
    printList(sum);

    return 0;
}

Java

// Java code to add two linked list using recursion

class Node {
    int data;
    Node next;

    Node(int val) {
            data = val;
            next = null;
        }
    }

class GfG { 

    // Function to reverse a linked list
    static Node reverse(Node head) {
        Node prev = null;
        Node curr = head;
        Node next = null;

        // Loop to reverse the linked list
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

	// Function to trim leading zeros in linked list
    static Node trimLeadingZeros(Node head) {
        while (head != null && head.data == 0) {
            head = head.next;
        }
        return head;
    }
  
    // Recursive function to add two numbers 
  	// represented by linked lists
    static Node addListRec(Node num1, Node num2,
                           					int[] carry) {
      	
        // Base case: If both lists are empty 
      	// and no carry is left
        if (num1 == null && num2 == null && carry[0] == 0) {
            return null;
        }

        int sum = carry[0];

        // Add the value from the first list if it exists
        if (num1 != null) {
            sum += num1.data;
            num1 = num1.next;
        }

        // Add the value from the second list if it exists
        if (num2 != null) {
            sum += num2.data;
            num2 = num2.next;
        }

        carry[0] = sum / 10;
        Node result = new Node(sum % 10);

        // Recursively add remaining digits
        result.next = addListRec(num1, num2, carry);

        return result;
    }

    // Function for adding two linked lists
    static Node addTwoLists(Node num1, Node num2) {
		num1 = trimLeadingZeros(num1);
        num2 = trimLeadingZeros(num2);
      
        // Reverse both lists to start addition from 
        // the least significant digit
        num1 = reverse(num1);
        num2 = reverse(num2);

      	// Array used to pass carry by reference
        int[] carry = new int[1];  
        Node result = addListRec(num1, num2, carry);

        // If there's any carry left after the addition, 
		// create a new node for it
        if (carry[0] != 0) {
            Node newNode = new Node(carry[0]);
            newNode.next = result;
            result = newNode;
        }

        // Reverse the list to restore the original order
        return reverse(result);
    }

    // Function to print a linked list
    static void printList(Node head) {
        Node curr = head;
        while (curr != null) {
            System.out.print(curr.data + " ");
            curr = curr.next;
        }
        System.out.println();
    }

    public static void main(String[] args) {
        
      	// Creating first linked list: 
      	// 1 -> 2 -> 3 (represents 123)
        Node num1 = new Node(1);
        num1.next = new Node(2);
        num1.next.next = new Node(3);

        // Creating second linked list: 
      	// 9 -> 9 -> 9 (represents 999)
        Node num2 = new Node(9);
        num2.next = new Node(9);
        num2.next.next = new Node(9);

        Node sum = addTwoLists(num1, num2);
        printList(sum);
    }
}

Python

# Python code to add two linked lists using recursion

import sys
class Node:
    def __init__(self, val):
        self.data = val
        self.next = None

# Function to reverse a linked list
def reverse(head):
    prev = None
    curr = head
    next = None

    # Loop to reverse the linked list
    while curr is not None:
        next = curr.next
        curr.next = prev
        prev = curr
        curr = next
    return prev

# function to trim leading zeros from linked list
def trimLeadingZeros(head):
    while head and head.data == 0:
        head = head.next
    return head
  
# Recursive function to add two numbers represented
# by linked lists
def addListRec(num1, num2, carry):
    
    # Base case: If both lists are empty and no carry is left
    if num1 is None and num2 is None and carry[0] == 0:
        return None

    sum = carry[0]

    # Add the value from the first list if it exists
    if num1 is not None:
        sum += num1.data
        num1 = num1.next

    # Add the value from the second list if it exists
    if num2 is not None:
        sum += num2.data
        num2 = num2.next

    carry[0] = sum // 10
    result = Node(sum % 10)

    # Recursively add remaining digits
    result.next = addListRec(num1, num2, carry)

    return result

# Function for adding two linked lists
def addTwoLists(num1, num2):
    num1 = trimLeadingZeros(num1)
    num2 = trimLeadingZeros(num2)
    
    # Reverse both lists to start addition from the 
    # least significant digit
    num1 = reverse(num1)
    num2 = reverse(num2)

    carry = [0]
    result = addListRec(num1, num2, carry)

    # If there's any carry left after the addition,
    # create a new node for it
    if carry[0] != 0:
        newNode = Node(carry[0])
        newNode.next = result
        result = newNode

    # Reverse the result list to restore the original order
    return reverse(result)

def printList(head):
    curr = head
    while curr is not None:
        print(curr.data, end=' ')
        curr = curr.next
    print()

if __name__ == "__main__":
  	
    # Creating first linked list: 
    # 1 -> 2 -> 3 (represents 123)
    num1 = Node(1)
    num1.next = Node(2)
    num1.next.next = Node(3)

    # Creating second linked list: 
    # 9 -> 9 -> 9 (represents 999)
    num2 = Node(9)
    num2.next = Node(9)
    num2.next.next = Node(9)

    sumList = addTwoLists(num1, num2)
    printList(sumList)

// C# code to add two linked list using recursion

using System;

class Node {
    public int data;
    public Node next;

    public Node(int val) {
        data = val;
        next = null;
    }
}

// Function to reverse a linked list
class GfG {
    static Node Reverse(Node head) {
        Node prev = null;
        Node curr = head;
        Node next = null;

        // Loop to reverse the linked list
        while (curr != null) {
            next = curr.next;
            curr.next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }

	// Function to trim leading zeros from linked list
    static Node TrimLeadingZeros(Node head) {
        while (head != null && head.data == 0) {
            head = head.next;
        }
        return head;
    }

    // Recursive function to add two numbers represented
  	// by linked lists
    static Node AddListRec(Node num1, Node num2, 
                           			ref int carry) {  
		num1 = TrimLeadingZeros(num1);
        num2 = TrimLeadingZeros(num2);
      
      	// Base case: If both lists are empty and
      	// no carry is left
        if (num1 == null && num2 == null && carry == 0) {
            return null;
        }

        int sum = carry;

        // Add the value from the first list if it exists
        if (num1 != null) {
            sum += num1.data;
            num1 = num1.next;
        }

        // Add the value from the second list if it exists
        if (num2 != null) {
            sum += num2.data;
            num2 = num2.next;
        }

        carry = sum / 10;
        Node result = new Node(sum % 10);

        // Recursively add remaining digits
        result.next = AddListRec(num1, num2, ref carry);

        return result;
    }

    // Function for adding two linked lists
    static Node AddTwoLists(Node num1, Node num2) {
        // Reverse both lists to start addition from 
        // the least significant digit
        num1 = Reverse(num1);
        num2 = Reverse(num2);

        int carry = 0;
        Node result = AddListRec(num1, num2, ref carry);

        // If there's any carry left after the addition,
        // create a new node for it
        if (carry != 0) {
            Node newNode = new Node(carry);
            newNode.next = result;
            result = newNode;
        }

        // Reverse the result list to restore
        // the original order
        return Reverse(result);
    }

    static void PrintList(Node head) {
        Node curr = head;
        while (curr != null) {
            Console.Write(curr.data + " ");
            curr = curr.next;
        }
        Console.WriteLine();
    }

    static void Main() {
        
      	// Creating first linked list: 1 -> 2 -> 3 
        // (represents 123)
        Node num1 = new Node(1);
        num1.next = new Node(2);
        num1.next.next = new Node(3);

        // Creating second linked list: 9 -> 9 -> 9 
        // (represents 999)
        Node num2 = new Node(9);
        num2.next = new Node(9);
        num2.next.next = new Node(9);

        Node sum = AddTwoLists(num1, num2);
        PrintList(sum);
    }
}

JavaScript

// Javascript code to add two linked list using recursion

class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}

// Function to reverse a linked list
function reverse(head) {
    let prev = null;
    let curr = head;
    let next = null;

    // Loop to reverse the linked list
    while (curr !== null) {
        next = curr.next;
        curr.next = prev;
        prev = curr;
        curr = next;
    }
    return prev;
}

function trimLeadingZeros(head) {
    while (head !== null && head.data === 0) {
        head = head.next;
    }
    return head;
}

// Recursive function to add two numbers represented
// by linked lists
function addListRec(num1, num2, carry) {

    // Base case: If both lists are empty and no carry is left
    if (num1 === null && num2 === null && carry === 0) {
        return null;
    }

    let sum = carry;

    // Add the value from the first list if it exists
    if (num1 !== null) {
        sum += num1.data;
        num1 = num1.next;
    }

    // Add the value from the second list if it exists
    if (num2 !== null) {
        sum += num2.data;
        num2 = num2.next;
    }

    carry = Math.floor(sum / 10);
    let result = new Node(sum % 10);

    // Recursively add remaining digits
    result.next = addListRec(num1, num2, carry);

    return result;
}

// Function for adding two linked lists
function addTwoLists(num1, num2) {
	num1 = trimLeadingZeros(num1);
    num2 = trimLeadingZeros(num2);

    // Reverse both lists to start addition from
    // the least significant digit
    num1 = reverse(num1);
    num2 = reverse(num2);

    let carry = 0;
    let result = addListRec(num1, num2, carry);

    // If there's any carry left after the addition,
    // create a new node for it
    if (carry !== 0) {
        let newNode = new Node(carry);
        newNode.next = result;
        result = newNode;
    }

    // Reverse the result list to restore
    // the original order
    return reverse(result);
}

function printList(head) {
    let curr = head;
    let result = '';
    while (curr !== null) {
        result += curr.data + ' ';
        curr = curr.next;
    }
    console.log(result.trim());
}

// Creating first linked list: 1 -> 2 -> 3
// (represents 123)
let num1 = new Node(1);
num1.next = new Node(2);
num1.next.next = new Node(3);

// Creating second linked list: 9 -> 9 -> 9
// (represents 999)
let num2 = new Node(9);
num2.next = new Node(9);
num2.next.next = new Node(9);

let sum = addTwoLists(num1, num2);
printList(sum);

Output

1 1 2 2

Time Complexity: O(m + n), where m and n are the sizes of given two linked lists.
Auxiliary Space: O(max(m, n))

Related article:

Add Two Numbers represented as Linked List

Add Two Numbers represented as Linked List using Recursion

Explore