用于减去表示为链接列表的两个数字的 Javascript 程序

给定两个表示两个大正数的链表。从较大的数字中减去较小的数字，并将差值作为链表返回。请注意，输入列表可以是任何顺序，但我们总是需要从较大的列表中减去较小的列表。
可以假设输入列表中没有额外的前导零。
例子：

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. 计算给定两个链表的大小。
2. 如果大小不同，则在较小的链表中附加零。
3. 如果大小相同，请按照以下步骤操作：
   1. 找到较小值的链表。
   2. 从较大的链表中一一减去较小链表的节点。减法时跟踪借位。

以下是上述方法的实现。

Javascript

// Javascript program to subtract smaller 
// valued list from larger valued list 
// and return result as a list.
  
// head of list
var head; 
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 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 code
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

输出：

0 9 9 

复杂性分析：

• 时间复杂度： O(n)。
  因为不需要嵌套遍历链表。
• 辅助空间： O(n)。
  如果考虑递归堆栈空间，则需要 O(n) 空间。

有关更多详细信息，请参阅有关以链接列表表示的减去两个数字的完整文章！