 GeeksforGeeks App
Open App Browser
Continue

# 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. ```

Approach: Following are the steps.

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 ``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 ``#include ``#include `` ` `// 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

 ``

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.

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.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 ``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)`

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)

This article is contributed by Mu Ven. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.