Subtract Two Numbers represented as Linked Lists

Given two linked lists that represent two large positive numbers. Subtract the smaller number from the larger one and return the difference as a linked list. Note that the input lists may be in any order, but we always need to subtract smaller ones from larger ones.
Note: It may be assumed that there are no extra leading zeros in input lists.

Examples:

Input: l1 = 1 -> 0 -> 0 -> NULL,  l2 = 1 -> NULL
Output: 0->9->9->NULL
Explanation: Number represented as 
lists are 100 and 1, so 100 - 1 is 099
Input: l1 = 7-> 8 -> 6 -> NULL,  l2 = 7 -> 8 -> 9 NULL
Output: 3->NULL
Explanation: Number represented as 
lists are 786 and  789, so 789 - 786 is 3, 
as the smaller value is subtracted from 
the larger one. 

1. Calculate sizes of given two linked lists.
2. If sizes are not the same, then append zeros in the smaller linked list.
3. If the size is the same, then follow the below steps:
   1. Find the smaller valued linked list.
   2. One by one subtract nodes of the smaller-sized linked list from the larger size. Keep track of borrow while subtracting.

Following is the implementation of the above approach. 

C++

// C++ program to subtract smaller valued list from
// larger valued list and return result as a list.
#include <bits/stdc++.h>
using namespace std;

// A linked List Node
struct Node {
    int data;
    struct Node* next;
};

// A utility which creates Node.
Node* newNode(int data)
{
    Node* temp = new Node;
    temp->data = data;
    temp->next = NULL;
    return temp;
}

/* A utility function to get length
 of linked list */
int getLength(Node* Node)
{
    int size = 0;
    while (Node != NULL) {
        Node = Node->next;
        size++;
    }
    return size;
}

/* A Utility that padds zeros in front of the
   Node, with the given diff */
Node* paddZeros(Node* sNode, int diff)
{
    if (sNode == NULL)
        return NULL;

    Node* zHead = newNode(0);
    diff--;
    Node* temp = zHead;
    while (diff--) {
        temp->next = newNode(0);
        temp = temp->next;
    }
    temp->next = sNode;
    return zHead;
}

/* Subtract LinkedList Helper is a recursive function,
   move till the last Node,  and subtract the digits and
   create the Node and return the Node. If d1 < d2, we
   borrow the number from previous digit. */
Node* subtractLinkedListHelper(Node* l1, Node* l2,
                               bool& borrow)
{
    if (l1 == NULL && l2 == NULL && borrow == 0)
        return NULL;

    Node* previous = subtractLinkedListHelper(
        l1 ? l1->next : NULL, l2 ? l2->next : NULL, borrow);

    int d1 = l1->data;
    int d2 = l2->data;
    int sub = 0;

    /* if you have given the value to next digit then
       reduce the d1 by 1 */
    if (borrow) {
        d1--;
        borrow = false;
    }

    /* If d1 < d2, then borrow the number from previous
       digit. Add 10 to d1 and set borrow = true; */
    if (d1 < d2) {
        borrow = true;
        d1 = d1 + 10;
    }

    /* subtract the digits */
    sub = d1 - d2;

    /* Create a Node with sub value */
    Node* current = newNode(sub);

    /* Set the Next pointer as Previous */
    current->next = previous;

    return current;
}

/* This API subtracts two linked lists and returns the
   linked list which shall  have the subtracted result. */
Node* subtractLinkedList(Node* l1, Node* l2)
{
    // Base Case.
    if (l1 == NULL && l2 == NULL)
        return NULL;

    // In either of the case, get the lengths of both
    // Linked list.
    int len1 = getLength(l1);
    int len2 = getLength(l2);

    Node *lNode = NULL, *sNode = NULL;

    Node* temp1 = l1;
    Node* temp2 = l2;

    // If lengths differ, calculate the smaller Node
    // and padd zeros for smaller Node and ensure both
    // larger Node and smaller Node has equal length.
    if (len1 != len2) {
        lNode = len1 > len2 ? l1 : l2;
        sNode = len1 > len2 ? l2 : l1;
        sNode = paddZeros(sNode, abs(len1 - len2));
    }

    else {
        // If both list lengths are equal, then calculate
        // the larger and smaller list. If 5-6-7 & 5-6-8
        // are linked list, then walk through linked list
        // at last Node as 7 < 8, larger Node is 5-6-8
        // and smaller Node is 5-6-7.
        while (l1 && l2) {
            if (l1->data != l2->data) {
                lNode = l1->data > l2->data ? temp1 : temp2;
                sNode = l1->data > l2->data ? temp2 : temp1;
                break;
            }
            l1 = l1->next;
            l2 = l2->next;
        }
    }
    // If both lNode and sNode still have NULL value,
    // then this means that the  value of both of the given
    // linked lists is the same and hence we can directly
    // return a node with value 0.
    if (lNode == NULL && sNode == NULL) {
        return newNode(0);
    }
    // After calculating larger and smaller Node, call
    // subtractLinkedListHelper which returns the subtracted
    // linked list.
    bool borrow = false;
    return subtractLinkedListHelper(lNode, sNode, borrow);
}

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

// Driver program to test above functions
int main()
{
    Node* head1 = newNode(1);
    head1->next = newNode(0);
    head1->next->next = newNode(0);

    Node* head2 = newNode(1);

    Node* result = subtractLinkedList(head1, head2);

    printList(result);

    return 0;
}

// This code is contributed by Sania Kumari Gupta (kriSania804)

C

// C program to subtract smaller valued list from
// larger valued list and return result as a list.
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>

// A linked List Node
typedef struct Node {
    int data;
    struct Node* next;
} Node;

// A utility which creates Node.
Node* newNode(int data)
{
    Node* temp = (Node*)malloc(sizeof(Node));
    temp->data = data;
    temp->next = NULL;
    return temp;
}

/* A utility function to get length
 of linked list */
int getLength(Node* Node)
{
    int size = 0;
    while (Node != NULL) {
        Node = Node->next;
        size++;
    }
    return size;
}

/* A Utility that padds zeros in front of the
   Node, with the given diff */
Node* paddZeros(Node* sNode, int diff)
{
    if (sNode == NULL)
        return NULL;

    Node* zHead = newNode(0);
    diff--;
    Node* temp = zHead;
    while (diff--) {
        temp->next = newNode(0);
        temp = temp->next;
    }
    temp->next = sNode;
    return zHead;
}

/* Subtract LinkedList Helper is a recursive function,
   move till the last Node,  and subtract the digits and
   create the Node and return the Node. If d1 < d2, we
   borrow the number from previous digit. */
static bool borrow;
Node* subtractLinkedListHelper(Node* l1, Node* l2)
{

    if (l1 == NULL && l2 == NULL && borrow == 0)
        return NULL;

    Node* previous = subtractLinkedListHelper(
        l1 ? l1->next : NULL, l2 ? l2->next : NULL);

    int d1 = l1->data;
    int d2 = l2->data;
    int sub = 0;

    /* if you have given the value to next digit then
       reduce the d1 by 1 */
    if (borrow) {
        d1--;
        borrow = false;
    }

    /* If d1 < d2, then borrow the number from previous
       digit. Add 10 to d1 and set borrow = true; */
    if (d1 < d2) {
        borrow = true;
        d1 = d1 + 10;
    }

    /* subtract the digits */
    sub = d1 - d2;

    /* Create a Node with sub value */
    Node* current = newNode(sub);

    /* Set the Next pointer as Previous */
    current->next = previous;

    return current;
}

/* This API subtracts two linked lists and returns the
   linked list which shall  have the subtracted result. */
Node* subtractLinkedList(Node* l1, Node* l2)
{
    // Base Case.
    if (l1 == NULL && l2 == NULL)
        return NULL;

    // In either of the case, get the lengths of both
    // Linked list.
    int len1 = getLength(l1);
    int len2 = getLength(l2);

    Node *lNode = NULL, *sNode = NULL;

    Node* temp1 = l1;
    Node* temp2 = l2;

    // If lengths differ, calculate the smaller Node
    // and padd zeros for smaller Node and ensure both
    // larger Node and smaller Node has equal length.
    if (len1 != len2) {
        lNode = len1 > len2 ? l1 : l2;
        sNode = len1 > len2 ? l2 : l1;
        sNode = paddZeros(sNode, abs(len1 - len2));
    }

    else {
        // If both list lengths are equal, then calculate
        // the larger and smaller list. If 5-6-7 & 5-6-8
        // are linked list, then walk through linked list
        // at last Node as 7 < 8, larger Node is 5-6-8
        // and smaller Node is 5-6-7.
        while (l1 && l2) {
            if (l1->data != l2->data) {
                lNode = l1->data > l2->data ? temp1 : temp2;
                sNode = l1->data > l2->data ? temp2 : temp1;
                break;
            }
            l1 = l1->next;
            l2 = l2->next;
        }
    }
    // If both lNode and sNode still have NULL value,
    // then this means that the  value of both of the given
    // linked lists is the same and hence we can directly
    // return a node with value 0.
    if (lNode == NULL && sNode == NULL) {
        return newNode(0);
    }
    // After calculating larger and smaller Node, call
    // subtractLinkedListHelper which returns the subtracted
    // linked list.
    borrow = false;
    return subtractLinkedListHelper(lNode, sNode);
}

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

// Driver program to test above functions
int main()
{
    Node* head1 = newNode(1);
    head1->next = newNode(0);
    head1->next->next = newNode(0);

    Node* head2 = newNode(1);

    Node* result = subtractLinkedList(head1, head2);

    printList(result);

    return 0;
}

// This code is contributed by Sania Kumari Gupta (kriSania804)

Java

// Java program to subtract smaller valued
// list from larger valued list and return
// result as a list.
import java.util.*;
import java.lang.*;
import java.io.*;

class LinkedList {
    static Node head; // head of list
    boolean borrow;

    /* Node Class */
    static class Node {
        int data;
        Node next;

        // Constructor to create a new node
        Node(int d)
        {
            data = d;
            next = null;
        }
    }

    /* A utility function to get length of
    linked list */
    int getLength(Node node)
    {
        int size = 0;
        while (node != null) {
            node = node.next;
            size++;
        }
        return size;
    }

    /* A Utility that padds zeros in front
    of the Node, with the given diff */
    Node paddZeros(Node sNode, int diff)
    {
        if (sNode == null)
            return null;

        Node zHead = new Node(0);
        diff--;
        Node temp = zHead;
        while ((diff--) != 0) {
            temp.next = new Node(0);
            temp = temp.next;
        }
        temp.next = sNode;
        return zHead;
    }

    /* Subtract LinkedList Helper is a recursive
    function, move till the last Node, and
    subtract the digits and create the Node and
    return the Node. If d1 < d2, we borrow the
    number from previous digit. */
    Node subtractLinkedListHelper(Node l1, Node l2)
    {
        if (l1 == null && l2 == null && borrow == false)
            return null;

        Node previous
            = subtractLinkedListHelper(
                (l1 != null) ? l1.next
                             : null,
                (l2 != null) ? l2.next : null);

        int d1 = l1.data;
        int d2 = l2.data;
        int sub = 0;

        /* if you have given the value to
        next digit then reduce the d1 by 1 */
        if (borrow) {
            d1--;
            borrow = false;
        }

        /* If d1 < d2, then borrow the number from
        previous digit. Add 10 to d1 and set
        borrow = true; */
        if (d1 < d2) {
            borrow = true;
            d1 = d1 + 10;
        }

        /* subtract the digits */
        sub = d1 - d2;

        /* Create a Node with sub value */
        Node current = new Node(sub);

        /* Set the Next pointer as Previous */
        current.next = previous;

        return current;
    }

    /* This API subtracts two linked lists and
    returns the linked list which shall have the
    subtracted result. */
    Node subtractLinkedList(Node l1, Node l2)
    {
        // Base Case.
        if (l1 == null && l2 == null)
            return null;

        // In either of the case, get the lengths
        // of both Linked list.
        int len1 = getLength(l1);
        int len2 = getLength(l2);

        Node lNode = null, sNode = null;

        Node temp1 = l1;
        Node temp2 = l2;

        // If lengths differ, calculate the smaller
        // Node and padd zeros for smaller Node and
        // ensure both larger Node and smaller Node
        // has equal length.
        if (len1 != len2) {
            lNode = len1 > len2 ? l1 : l2;
            sNode = len1 > len2 ? l2 : l1;
            sNode = paddZeros(sNode, Math.abs(len1 - len2));
        }

        else {
            // If both list lengths are equal, then
            // calculate the larger and smaller list.
            // If 5-6-7 & 5-6-8 are linked list, then
            // walk through linked list at last Node
            // as 7 < 8, larger Node is 5-6-8 and
            // smaller Node is 5-6-7.
            while (l1 != null && l2 != null) {
                if (l1.data != l2.data) {
                    lNode = l1.data > l2.data ? temp1 : temp2;
                    sNode = l1.data > l2.data ? temp2 : temp1;
                    break;
                }
                l1 = l1.next;
                l2 = l2.next;
            }
        }

        // After calculating larger and smaller Node,
        // call subtractLinkedListHelper which returns
        // the subtracted linked list.
        borrow = false;
        return subtractLinkedListHelper(lNode, sNode);
    }

    // function to display the linked list
    static void printList(Node head)
    {
        Node temp = head;
        while (temp != null) {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
    }

    // Driver program to test above
    public static void main(String[] args)
    {
        Node head = new Node(1);
        head.next = new Node(0);
        head.next.next = new Node(0);

        Node head2 = new Node(1);

        LinkedList ob = new LinkedList();
        Node result = ob.subtractLinkedList(head, head2);

        printList(result);
    }
}

// This article is contributed by Chhavi

Python

# Python program to subtract smaller valued list from
# larger valued list and return result as a list.

# A linked List Node
class Node:
    def __init__(self, new_data):
        self.data = new_data
        self.next = None

# A utility which creates Node.
def newNode(data):

    temp = Node(0)
    temp.data = data
    temp.next = None
    return temp

# A utility function to get length of linked list
def getLength(Node):

    size = 0
    while (Node != None):

        Node = Node.next
        size = size + 1

    return size

# A Utility that padds zeros in front of the
# Node, with the given diff
def paddZeros( sNode, diff):

    if (sNode == None):
        return None

    zHead = newNode(0)
    diff = diff - 1
    temp = zHead
    while (diff > 0):
        diff = diff - 1
        temp.next = newNode(0)
        temp = temp.next

    temp.next = sNode
    return zHead

borrow = True

# Subtract LinkedList Helper is a recursive function,
# move till the last Node, and subtract the digits and
# create the Node and return the Node. If d1 < d2, we
# borrow the number from previous digit.
def subtractLinkedListHelper(l1, l2):

    global borrow

    if (l1 == None and l2 == None and not borrow ):
        return None

    l3 = None
    l4 = None
    if(l1 != None):
        l3 = l1.next
    if(l2 != None):
        l4 = l2.next
    previous = subtractLinkedListHelper(l3, l4)

    d1 = l1.data
    d2 = l2.data
    sub = 0

    # if you have given the value to next digit then
    # reduce the d1 by 1
    if (borrow):
        d1 = d1 - 1
        borrow = False

    # If d1 < d2, then borrow the number from previous digit.
    # Add 10 to d1 and set borrow = True
    if (d1 < d2):
        borrow = True
        d1 = d1 + 10

    # subtract the digits
    sub = d1 - d2

    # Create a Node with sub value
    current = newNode(sub)

    # Set the Next pointer as Previous
    current.next = previous

    return current

# This API subtracts two linked lists and returns the
# linked list which shall have the subtracted result.
def subtractLinkedList(l1, l2):

    # Base Case.
    if (l1 == None and l2 == None):
        return None

    # In either of the case, get the lengths of both
    # Linked list.
    len1 = getLength(l1)
    len2 = getLength(l2)

    lNode = None
    sNode = None

    temp1 = l1
    temp2 = l2

    # If lengths differ, calculate the smaller Node
    # and padd zeros for smaller Node and ensure both
    # larger Node and smaller Node has equal length.
    if (len1 != len2):
        if(len1 > len2):
            lNode = l1
        else:
            lNode = l2

        if(len1 > len2):
            sNode = l2
        else:
            sNode = l1
        sNode = paddZeros(sNode, abs(len1 - len2))

    else:

        # If both list lengths are equal, then calculate
        # the larger and smaller list. If 5-6-7 & 5-6-8
        # are linked list, then walk through linked list
        # at last Node as 7 < 8, larger Node is 5-6-8
        # and smaller Node is 5-6-7.
        while (l1 != None and l2 != None):

            if (l1.data != l2.data):
                if(l1.data > l2.data ):
                    lNode = temp1
                else:
                    lNode = temp2

                if(l1.data > l2.data ):
                    sNode = temp2
                else:
                    sNode = temp1
                break

            l1 = l1.next
            l2 = l2.next

    global borrow

    # After calculating larger and smaller Node, call
    # subtractLinkedListHelper which returns the subtracted
    # linked list.
    borrow = False
    return subtractLinkedListHelper(lNode, sNode)

# A utility function to print linked list
def printList(Node):

    while (Node != None):

        print (Node.data, end =" ")
        Node = Node.next

    print(" ")


# Driver program to test above functions

head1 = newNode(1)
head1.next = newNode(0)
head1.next.next = newNode(0)

head2 = newNode(1)

result = subtractLinkedList(head1, head2)

printList(result)

# This code is contributed by Arnab Kundu

C#

// C# program to subtract smaller valued
// list from larger valued list and return
// result as a list.
using System;

public class LinkedList {
    static Node head; // head of list
    bool borrow;

    /* Node Class */
    public class Node {
        public int data;
        public Node next;

        // Constructor to create a new node
        public Node(int d)
        {
            data = d;
            next = null;
        }
    }

    /* A utility function to get length of
    linked list */
    int getLength(Node node)
    {
        int size = 0;
        while (node != null) {
            node = node.next;
            size++;
        }
        return size;
    }

    /* A Utility that padds zeros in front
    of the Node, with the given diff */
    Node paddZeros(Node sNode, int diff)
    {
        if (sNode == null)
            return null;

        Node zHead = new Node(0);
        diff--;
        Node temp = zHead;
        while ((diff--) != 0) {
            temp.next = new Node(0);
            temp = temp.next;
        }
        temp.next = sNode;
        return zHead;
    }

    /* Subtract LinkedList Helper is a recursive
    function, move till the last Node, and
    subtract the digits and create the Node and
    return the Node. If d1 < d2, we borrow the
    number from previous digit. */
    Node subtractLinkedListHelper(Node l1, Node l2)
    {
        if (l1 == null && l2 == null && borrow == false)
            return null;

        Node previous = subtractLinkedListHelper((l1 != null) ? l1.next : null, (l2 != null) ? l2.next : null);

        int d1 = l1.data;
        int d2 = l2.data;
        int sub = 0;

        /* if you have given the value to
        next digit then reduce the d1 by 1 */
        if (borrow) {
            d1--;
            borrow = false;
        }

        /* If d1 < d2, then borrow the number from
        previous digit. Add 10 to d1 and set
        borrow = true; */
        if (d1 < d2) {
            borrow = true;
            d1 = d1 + 10;
        }

        /* subtract the digits */
        sub = d1 - d2;

        /* Create a Node with sub value */
        Node current = new Node(sub);

        /* Set the Next pointer as Previous */
        current.next = previous;

        return current;
    }

    /* This API subtracts two linked lists and
    returns the linked list which shall have the
    subtracted result. */
    Node subtractLinkedList(Node l1, Node l2)
    {
        // Base Case.
        if (l1 == null && l2 == null)
            return null;

        // In either of the case, get the lengths
        // of both Linked list.
        int len1 = getLength(l1);
        int len2 = getLength(l2);

        Node lNode = null, sNode = null;

        Node temp1 = l1;
        Node temp2 = l2;

        // If lengths differ, calculate the smaller
        // Node and padd zeros for smaller Node and
        // ensure both larger Node and smaller Node
        // has equal length.
        if (len1 != len2) {
            lNode = len1 > len2 ? l1 : l2;
            sNode = len1 > len2 ? l2 : l1;
            sNode = paddZeros(sNode, Math.Abs(len1 - len2));
        }

        else {
            // If both list lengths are equal, then
            // calculate the larger and smaller list.
            // If 5-6-7 & 5-6-8 are linked list, then
            // walk through linked list at last Node
            // as 7 < 8, larger Node is 5-6-8 and
            // smaller Node is 5-6-7.
            while (l1 != null && l2 != null) {
                if (l1.data != l2.data) {
                    lNode = l1.data > l2.data ? temp1 : temp2;
                    sNode = l1.data > l2.data ? temp2 : temp1;
                    break;
                }
                l1 = l1.next;
                l2 = l2.next;
            }
        }

        // After calculating larger and smaller Node,
        // call subtractLinkedListHelper which returns
        // the subtracted linked list.
        borrow = false;
        return subtractLinkedListHelper(lNode, sNode);
    }

    // function to display the linked list
    static void printList(Node head)
    {
        Node temp = head;
        while (temp != null) {
            Console.Write(temp.data + " ");
            temp = temp.next;
        }
    }

    // Driver code
    public static void Main(String[] args)
    {
        Node head = new Node(1);
        head.next = new Node(0);
        head.next.next = new Node(0);

        Node head2 = new Node(1);

        LinkedList ob = new LinkedList();
        Node result = ob.subtractLinkedList(head, head2);

        printList(result);
    }
}

// This code has been contributed by 29AjayKumar

Javascript

<script>

// Javascript program to subtract smaller valued
// list from larger valued list and return
// result as a list.

    var head; // head of list
    var borrow;

    /* Node Class */
     class Node {


        // Constructor to create a new node

    constructor(d) {
        this.data = d;
        this.next = null;
    }
}

    /*
     A utility function to get length of linked list
     */
    function getLength(node) {
        var size = 0;
        while (node != null) {
            node = node.next;
            size++;
        }
        return size;
    }

    /*
      A Utility that padds zeros in
     front of the Node, with the given diff
     */
    function paddZeros(sNode , diff) {
        if (sNode == null)
            return null;

var zHead = new Node(0);
        diff--;
var temp = zHead;
        while ((diff--) != 0) {
            temp.next = new Node(0);
            temp = temp.next;
        }
        temp.next = sNode;
        return zHead;
    }

    /*
     Subtract LinkedList Helper is a
     recursive function, move till the last Node,
     and subtract the digits and create the Node
     and return the Node. If d1 < d2,
     * we borrow the number from previous digit.
     */
    function subtractLinkedListHelper(l1,  l2) {
        if (l1 == null && l2 == null && borrow == false)
            return null;

       var previous = subtractLinkedListHelper((l1 != null) ?
       l1.next : null, (l2 != null) ? l2.next : null);

        var d1 = l1.data;
        var d2 = l2.data;
        var sub = 0;

        /*
         if you have given the value to next
         digit then reduce the d1 by 1
         */
        if (borrow) {
            d1--;
            borrow = false;
        }

        /*
         If d1 < d2, then borrow the number from
         previous digit. Add 10 to d1 and set
         borrow = true;
         */
        if (d1 < d2) {
            borrow = true;
            d1 = d1 + 10;
        }

        /* subtract the digits */
        sub = d1 - d2;

        /* Create a Node with sub value */
var current = new Node(sub);

        /* Set the Next pointer as Previous */
        current.next = previous;

        return current;
    }

    /*
     This API subtracts two linked lists
     and returns the linked list which shall
     have the subtracted result.
     */
    function subtractLinkedList(l1,  l2) {
        // Base Case.
        if (l1 == null && l2 == null)
            return null;

        // In either of the case, get the lengths
        // of both Linked list.
        var len1 = getLength(l1);
        var len2 = getLength(l2);

var lNode = null, sNode = null;

var temp1 = l1;
var temp2 = l2;

        // If lengths differ, calculate the smaller
        // Node and padd zeros for smaller Node and
        // ensure both larger Node and smaller Node
        // has equal length.
        if (len1 != len2) {
            lNode = len1 > len2 ? l1 : l2;
            sNode = len1 > len2 ? l2 : l1;
            sNode = paddZeros(sNode, Math.abs(len1 - len2));
        }

        else {
            // If both list lengths are equal, then
            // calculate the larger and smaller list.
            // If 5-6-7 & 5-6-8 are linked list, then
            // walk through linked list at last Node
            // as 7 < 8, larger Node is 5-6-8 and
            // smaller Node is 5-6-7.
            while (l1 != null && l2 != null) {
                if (l1.data != l2.data) {
                    lNode = l1.data > l2.data ? temp1 : temp2;
                    sNode = l1.data > l2.data ? temp2 : temp1;
                    break;
                }
                l1 = l1.next;
                l2 = l2.next;
            }
        }

        // After calculating larger and smaller Node,
        // call subtractLinkedListHelper which returns
        // the subtracted linked list.
        borrow = false;
        return subtractLinkedListHelper(lNode, sNode);
    }

    // function to display the linked list
    function printList(head) {
var temp = head;
        while (temp != null) {
            document.write(temp.data + " ");
            temp = temp.next;
        }
    }

    // Driver program to test above

var head = new Node(1);
        head.next = new Node(0);
        head.next.next = new Node(0);

var head2 = new Node(1);

var result = subtractLinkedList(head, head2);

        printList(result);

// This code contributed by aashish1995

</script>

Output

0 9 9 

Complexity Analysis:

• Time complexity: O(n). 
  As no nested traversal of linked list is needed.
• Auxiliary Space: O(n). 
  If recursive stack space is taken into consideration O(n) space is needed.

Approach 2 (Using 10s complement and linked list addition) :

The approach is similar to this. 
The idea is to use 10s complement arithmetic to perform the subtraction. 

Number1 – Number2 = Number1 + (- Number2) = Number1 + (10’s complement of Number2) 

Number1 – Number2 = Number1 + (9’s complement of Number2) + 1

The 9’s complement can be easily calculated on the go by subtracting each digit from 9. Now, the problem is converted to addition of two numbers represented as linked list.

Follow the steps below to implement the above idea:

1. Remove all the initial zeroes from both the linked lists.
2. Calculate length of both linked list.
3. Determine which number is greater and store it in list 1 (L1) and smaller one in list 2 (L2)
4. Now perform addition of linked list while converting L2 to 10’s complement
   4.1 Initialize carry = 1 because 10’s complement = 9’s complement + 1
   4.2 Reverse both linked list
   4.3 For each node, add the value of L1 and 9’s complement of value of L2 and carry i.e. sum = (L1 value) + (9 – L2 value) + carry
   4.4 Calculate carry = (sum / 10) and sum = (sum % 10) and store sum in a new node
5. After getting the resulting list, reverse it and remove initial zeroes
6. If resulting list becomes empty, add a new node with value 0 (zero), otherwise the remaining list is the answer

Below is the implementation of the above approach:

C++

// C++ program to subtract smaller valued list from
// larger valued list and return result as a list using 10's
// complement.
#include <bits/stdc++.h>
using namespace std;

// A linked List Node
struct Node {
    int data;
    struct Node* next;
};

// A utility which creates Node.
Node* newNode(int data)
{
    Node* temp = new Node;
    temp->data = data;
    temp->next = NULL;
    return temp;
}

/* A utility function to get length
of linked list */
int getLength(Node* Node)
{
    int size = 0;
    while (Node != NULL) {
        Node = Node->next;
        size++;
    }
    return size;
}

// A utility function to reverse the list
Node* reverse(Node* head)
{
    Node *prev = NULL, *next;
    while (head != NULL) {
        next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

/* Subtract LinkedList Helper is an iterative function,
Reverse the linked list, and perform addition of
linked list after converting L2 to 10's complement */
Node* subtractLinkedListHelper(Node* l1, Node* l2)
{
    // reverse both linked list
    l1 = reverse(l1);
    l2 = reverse(l2);

    // Initialize carry = 1 for making 10s
    //  complement using 9's complement
    // 10's complement = 9's complement + 1
    int carry = 1, sum;
    Node *res = NULL, *temp;

    // Repeat while any of list is not empty
    while (l1 != NULL || l2 != NULL) {
        sum = carry;

        // If L1 is not empty
        if (l1) {
            sum += l1->data;
            l1 = l1->next;
        }

        // If L2 is not empty
        if (l2) {
            sum += (9 - l2->data);
            l2 = l2->next;
        }

        // Otherwise consider l2->data as 0 (zero)
        else {
            sum += 9;
        }

        carry = sum / 10;
        sum = sum % 10;

        // If result has no digit yet
        if (res == NULL) {
            res = newNode(sum);
            temp = res;
        }

        // otherwise append the data to result linked list
        else {
            temp->next = newNode(sum);
            temp = temp->next;
        }
    }

    // Reverse the resulting linked list
    res = reverse(res);

    // remove initial zeroes
    while (res && res->data == 0)
        res = res->next;

    return res;
}

// This function subtracts two linked lists and returns the
// linked list which shall have the subtracted result.
Node* subtractLinkedList(Node* l1, Node* l2)
{
    // Base Case.
    if (l1 == NULL && l2 == NULL)
        return NULL;

    // Remove initial zeroes
    while (l1 != NULL && l1->data == 0)
        l1 = l1->next;
    while (l2 != NULL && l2->data == 0)
        l2 = l2->next;

    // determine which one is bigger and which is smaller
    // and store larger in l1 and smaller in l2

    // Get length of both the linked list
    int len1 = getLength(l1);
    int len2 = getLength(l2);

    // If length of both linked list is same
    // then determine which one is bigger using the data
    if (len1 == len2) {
        Node *a = l1, *b = l2;
        while (a != NULL && b != NULL
               && a->data == b->data) {
            a = a->next;
            b = b->next;
        }

        // if b's value is greater than a's value
        // then l2 is larger number than l1
        if (a != NULL && b != NULL && a->data < b->data) {
            swap(l1, l2);
        }
    }
    // If length(l2) is greater than length(l1)
    // then l2 is larger and l1 is smaller
    else if (len2 > len1) {
        swap(l1, l2);
    }

    // Get subtraction result using 10's complement
    Node* res = subtractLinkedListHelper(l1, l2);

    // If res is NULL, then it means
    // both numbers are same and answer is zero

    if (res == NULL) {
        return newNode(0);
    }

    return res;
}

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

// Driver Code
int main()
{
    Node* head1 = newNode(1);
    head1->next = newNode(0);
    head1->next->next = newNode(0);

    Node* head2 = newNode(1);

    Node* result = subtractLinkedList(head1, head2);

    printList(result);

    return 0;
}

// This code is contributed by Piyush Garg (infinity4321cg)

Java

class Node {
    int data;
    Node next;

    Node(int data) {
        this.data = data;
        next = null;
    }
}

public class Main {
    // A utility which creates Node.
    static Node newNode(int data) {
        Node temp = new Node(data);
        temp.next = null;
        return temp;
    }

    // A utility function to get length of linked list
    static int getLength(Node head) {
        int size = 0;
        while (head != null) {
            head = head.next;
            size++;
        }
        return size;
    }

    // A utility function to reverse the list
    static Node reverse(Node head) {
        Node prev = null;
        while (head != null) {
            Node next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        return prev;
    }

    // Subtract LinkedList Helper is an iterative function,
    // Reverse the linked list, and perform addition of
    // linked list after converting L2 to 10's complement
    static Node subtractLinkedListHelper(Node l1, Node l2) {
        // reverse both linked list
        l1 = reverse(l1);
        l2 = reverse(l2);

        // Initialize carry = 1 for making 10s
        // complement using 9's complement
        // 10's complement = 9's complement + 1
        int carry = 1, sum;
        Node res = null;
        Node temp = null;

        // Repeat while any of list is not empty
        while (l1 != null || l2 != null) {
            sum = carry;

            // If L1 is not empty
            if (l1 != null) {
                sum += l1.data;
                l1 = l1.next;
            }

            // If L2 is not empty
            if (l2 != null) {
                sum += (9 - l2.data);
                l2 = l2.next;
            }

            // Otherwise consider l2->data as 0 (zero)
            else {
                sum += 9;
            }

            carry = sum / 10;
            sum = sum % 10;

            // If result has no digit yet
            if (res == null) {
                res = newNode(sum);
                temp = res;
            }
            // otherwise append the data to result linked list
            else {
                temp.next = newNode(sum);
                temp = temp.next;
            }
        }

        // Reverse the resulting linked list
        res = reverse(res);

        // remove initial zeroes
        while (res != null && res.data == 0)
            res = res.next;

        return res;
    }

    // This function subtracts two linked lists and returns the
    // linked list which shall have the subtracted result.
    static Node subtractLinkedList(Node l1, Node l2) {
        // Base Case.
        if (l1 == null && l2 == null)
            return null;

        // Remove initial zeroes
        while (l1 != null && l1.data == 0)
            l1 = l1.next;
        while (l2 != null && l2.data == 0)
            l2 = l2.next;

        // Determine which one is bigger and which is smaller
        // Store larger in l1 and smaller in l2

        // Get length of both the linked list
        int len1 = getLength(l1);
        int len2 = getLength(l2);

        // If length of both linked list is the same
        // then determine which one is bigger using the data
        if (len1 == len2) {
            Node a = l1, b = l2;
            while (a != null && b != null && a.data == b.data) {
                a = a.next;
                b = b.next;
            }

            // If b's value is greater than a's value
            // then l2 is a larger number than l1
            if (a != null && b != null && a.data < b.data) {
                Node temp = l1;
                l1 = l2;
                l2 = temp;
            }
        }
        // If length(l2) is greater than length(l1)
        // then l2 is larger and l1 is smaller
        else if (len2 > len1) {
            Node temp = l1;
            l1 = l2;
            l2 = temp;
        }

        // Get subtraction result using 10's complement
        Node res = subtractLinkedListHelper(l1, l2);

        // If res is NULL, then it means both numbers are the same and the answer is zero
        if (res == null) {
            return newNode(0);
        }

        return res;
    }

    // A utility function to print linked list
    static void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }
        System.out.println();
    }

    // Driver Code
    public static void main(String[] args) {
        Node head1 = newNode(1);
        head1.next = newNode(0);
        head1.next.next = newNode(0);

        Node head2 = newNode(1);

        Node result = subtractLinkedList(head1, head2);

        printList(result);
    }
}

Python3

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

def newNode(data):
    temp = Node(data)
    temp.next = None
    return temp

def getLength(head):
    size = 0
    while head is not None:
        head = head.next
        size += 1
    return size

def reverse(head):
    prev = None
    while head is not None:
        next = head.next
        head.next = prev
        prev = head
        head = next
    return prev

def subtractLinkedListHelper(l1, l2):
    l1 = reverse(l1)
    l2 = reverse(l2)
    carry = 1
    res = None
    temp = None

    while l1 is not None or l2 is not None:
        sum = carry
        if l1 is not None:
            sum += l1.data
            l1 = l1.next

        if l2 is not None:
            sum += (9 - l2.data)
            l2 = l2.next
        else:
            sum += 9

        carry = sum // 10
        sum = sum % 10

        if res is None:
            res = newNode(sum)
            temp = res
        else:
            temp.next = newNode(sum)
            temp = temp.next

    res = reverse(res)

    while res is not None and res.data == 0:
        res = res.next

    return res

def subtractLinkedList(l1, l2):
    if l1 is None and l2 is None:
        return None

    while l1 is not None and l1.data == 0:
        l1 = l1.next
    while l2 is not None and l2.data == 0:
        l2 = l2.next

    len1 = getLength(l1)
    len2 = getLength(l2)

    if len1 == len2:
        a, b = l1, l2
        while a is not None and b is not None and a.data == b.data:
            a = a.next
            b = b.next

        if a is not None and b is not None and a.data < b.data:
            l1, l2 = l2, l1
    elif len2 > len1:
        l1, l2 = l2, l1

    res = subtractLinkedListHelper(l1, l2)

    if res is None:
        return newNode(0)

    return res

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

head1 = newNode(1)
head1.next = newNode(0)
head1.next.next = newNode(0)

head2 = newNode(1)

result = subtractLinkedList(head1, head2)

printList(result)

C#

using System;

public class Node
{
    public int data;
    public Node next;

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

public class GFG
{
    // A utility which creates Node.
    static Node newNode(int data)
    {
        Node temp = new Node(data);
        temp.next = null;
        return temp;
    }

    // A utility function to get length of linked list
    static int getLength(Node head)
    {
        int size = 0;
        while (head != null)
        {
            head = head.next;
            size++;
        }
        return size;
    }

    // A utility function to reverse the list
    static Node reverse(Node head)
    {
        Node prev = null;
        while (head != null)
        {
            Node next = head.next;
            head.next = prev;
            prev = head;
            head = next;
        }
        return prev;
    }

    // Subtract LinkedList Helper is an iterative function,
    // Reverse the linked list, and perform addition of
    // linked list after converting L2 to 10's complement
    static Node subtractLinkedListHelper(Node l1, Node l2)
    {
        // reverse both linked list
        l1 = reverse(l1);
        l2 = reverse(l2);

        // Initialize carry = 1 for making 10s
        // complement using 9's complement
        // 10's complement = 9's complement + 1
        int carry = 1, sum;
        Node res = null;
        Node temp = null;

        // Repeat while any of list is not empty
        while (l1 != null || l2 != null)
        {
            sum = carry;

            // If L1 is not empty
            if (l1 != null)
            {
                sum += l1.data;
                l1 = l1.next;
            }

            // If L2 is not empty
            if (l2 != null)
            {
                sum += (9 - l2.data);
                l2 = l2.next;
            }

            // Otherwise consider l2->data as 0 (zero)
            else
            {
                sum += 9;
            }

            carry = sum / 10;
            sum = sum % 10;

            // If result has no digit yet
            if (res == null)
            {
                res = newNode(sum);
                temp = res;
            }
            // otherwise append the data to result linked list
            else
            {
                temp.next = newNode(sum);
                temp = temp.next;
            }
        }

        // Reverse the resulting linked list
        res = reverse(res);

        // remove initial zeroes
        while (res != null && res.data == 0)
            res = res.next;

        return res;
    }

    // This function subtracts two linked lists and returns the
    // linked list which shall have the subtracted result.
    static Node subtractLinkedList(Node l1, Node l2)
    {
        // Base Case.
        if (l1 == null && l2 == null)
            return null;

        // Remove initial zeroes
        while (l1 != null && l1.data == 0)
            l1 = l1.next;
        while (l2 != null && l2.data == 0)
            l2 = l2.next;

        // Determine which one is bigger and which is smaller
        // Store larger in l1 and smaller in l2

        // Get length of both the linked list
        int len1 = getLength(l1);
        int len2 = getLength(l2);

        // If length of both linked list is the same
        // then determine which one is bigger using the data
        if (len1 == len2)
        {
            Node a = l1, b = l2;
            while (a != null && b != null && a.data == b.data)
            {
                a = a.next;
                b = b.next;
            }

            // If b's value is greater than a's value
            // then l2 is a larger number than l1
            if (a != null && b != null && a.data < b.data)
            {
                Node temp = l1;
                l1 = l2;
                l2 = temp;
            }
        }
        // If length(l2) is greater than length(l1)
        // then l2 is larger and l1 is smaller
        else if (len2 > len1)
        {
            Node temp = l1;
            l1 = l2;
            l2 = temp;
        }

        // Get subtraction result using 10's complement
        Node res = subtractLinkedListHelper(l1, l2);

        // If res is NULL, then it means both numbers are the same and the answer is zero
        if (res == null)
        {
            return newNode(0);
        }

        return res;
    }

    // A utility function to print linked list
    static void printList(Node node)
    {
        while (node != null)
        {
            Console.Write(node.data + " ");
            node = node.next;
        }
        Console.WriteLine();
    }

    // Driver Code
    public static void Main(String[] args)
    {
        Node head1 = newNode(1);
        head1.next = newNode(0);
        head1.next.next = newNode(0);

        Node head2 = newNode(1);

        Node result = subtractLinkedList(head1, head2);

        printList(result);
    }
}

Javascript

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

function newNode(data) {
    const temp = new Node(data);
    temp.next = null;
    return temp;
}

function getLength(head) {
    let size = 0;
    while (head !== null) {
        head = head.next;
        size++;
    }
    return size;
}

function reverse(head) {
    let prev = null;
    while (head !== null) {
        const next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

function subtractLinkedListHelper(l1, l2) {
    l1 = reverse(l1);
    l2 = reverse(l2);
    let carry = 1;
    let res = null;
    let temp = null;

    while (l1 !== null || l2 !== null) {
        let sum = carry;
        if (l1 !== null) {
            sum += l1.data;
            l1 = l1.next;
        }

        if (l2 !== null) {
            sum += (9 - l2.data);
            l2 = l2.next;
        } else {
            sum += 9;
        }

        carry = Math.floor(sum / 10);
        sum %= 10;

        if (res === null) {
            res = newNode(sum);
            temp = res;
        } else {
            temp.next = newNode(sum);
            temp = temp.next;
        }
    }

    res = reverse(res);

    while (res !== null && res.data === 0) {
        res = res.next;
    }

    return res;
}

function subtractLinkedList(l1, l2) {
    if (l1 === null && l2 === null) {
        return null;
    }

    while (l1 !== null && l1.data === 0) {
        l1 = l1.next;
    }
    while (l2 !== null && l2.data === 0) {
        l2 = l2.next;
    }

    const len1 = getLength(l1);
    const len2 = getLength(l2);

    if (len1 === len2) {
        let a = l1;
        let b = l2;
        while (a !== null && b !== null && a.data === b.data) {
            a = a.next;
            b = b.next;
        }

        if (a !== null && b !== null && a.data < b.data) {
            [l1, l2] = [l2, l1];
        }
    } else if (len2 > len1) {
        [l1, l2] = [l2, l1];
    }

    const res = subtractLinkedListHelper(l1, l2);

    if (res === null) {
        return newNode(0);
    }

    return res;
}

function printList(head) {
    while (head !== null) {
        process.stdout.write(head.data + " ");
        head = head.next;
    }
}

const head1 = newNode(1);
head1.next = newNode(0);
head1.next.next = newNode(0);

const head2 = newNode(1);

const result = subtractLinkedList(head1, head2);

printList(result);

Output

9 9 

Complexity Analysis: 

• Time complexity: O(n). 
  As no nested traversal of linked list is needed.
• Auxiliary Space: O(n). 
  O(n) space is needed to store the resultant list, but it can be made to O(1) space by storing the result in original linked list.

This approach is contributed by Piyush Garg (infinity4321cg)