Python Program To 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 from the larger ones.
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.
- Calculate sizes of given two linked lists.
- If sizes are not the same, then append zeros in the smaller linked list.
- If the size is the same, then follow the below steps:
- Find the smaller valued linked list.
- 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.
Python
class Node:
def __init__( self , new_data):
self .data = new_data
self . next = None
def newNode(data):
temp = Node( 0 )
temp.data = data
temp. next = None
return temp
def getLength(Node):
size = 0
while (Node ! = None ):
Node = Node. next
size = size + 1
return size
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
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 (borrow):
d1 = d1 - 1
borrow = False
if (d1 < d2):
borrow = True
d1 = d1 + 10
sub = d1 - d2
current = newNode(sub)
current. next = previous
return current
def subtractLinkedList(l1, l2):
if (l1 = = None and l2 = = None ):
return None
len1 = getLength(l1)
len2 = getLength(l2)
lNode = None
sNode = None
temp1 = l1
temp2 = l2
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 :
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
borrow = False
return subtractLinkedListHelper(lNode,
sNode)
def printList(Node):
while (Node ! = None ):
print (Node.data,
end = " " )
Node = Node. next
print ( " " )
head1 = newNode( 1 )
head1. next = newNode( 0 )
head1. next . next = newNode( 0 )
head2 = newNode( 1 )
result = subtractLinkedList(head1, head2)
printList(result)
|
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.
Please refer complete article on Subtract Two Numbers represented as Linked Lists for more details!
Last Updated :
03 Jan, 2022
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...