用链表表示的两个数字相减的Python程序
给定两个表示两个大正数的链表。从较大的数字中减去较小的数字，并将差值作为链表返回。请注意，输入列表可以是任何顺序，但我们总是需要从较大的列表中减去较小的列表。
可以假设输入列表中没有额外的前导零。
例子：
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.方法：以下是步骤。
- 计算给定两个链表的大小。
- 如果大小不同，则在较小的链表中附加零。
- 如果大小相同，请按照以下步骤操作：
- 找到较小值的链表。
- 从较大的链表中一一减去较小链表的节点。减法时跟踪借位。
以下是上述方法的实现。
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 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 code
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输出：
0 9 9
复杂性分析：
- 时间复杂度： O(n)。
因为不需要嵌套遍历链表。 - 辅助空间： O(n)。
如果考虑递归堆栈空间，则需要 O(n) 空间。
有关更多详细信息，请参阅有关以链接列表表示的减去两个数字的完整文章！