Javascript 程序查找给定链表的最后 N 个节点的总和

给定一个链表和一个数字n 。求链表最后n 个节点的总和。
约束： 0 <= n <= 链表中的节点数。

例子：

Input : 10->6->8->4->12, n = 2
Output : 16
Sum of last two nodes:
12 + 4 = 16

Input : 15->7->9->5->16->14, n = 4
Output : 44

方法一：（使用系统调用栈的递归方式）
递归遍历链表直到结束。现在在从函数调用返回期间，将最后的n 个节点相加。总和可以累积在通过引用传递给函数或某个全局变量的某个变量中。

Javascript

  
// JavaScript implementation to find the sum of
// last 'n' nodes of the Linked List
      
    /* A Linked list node */
    class Node
    {
        constructor()
        {
            this.data;
            this.next;
        }
    }
      
    let head;
    let n, sum;
    // function to insert a node at the
    // beginning of the linked list
    function push(head_ref,new_data)
    {
        /* allocate node */
    let new_node = new Node();
       
    /* put in the data */
    new_node.data = new_data;
       
    /* link the old list to the new node */
    new_node.next = head_ref;
       
    /* move the head to point to the new node */
    head_ref = new_node;
    head = head_ref;
    }
      
    // function to recursively find the sum of last
    // 'n' nodes of the given linked list
    function sumOfLastN_Nodes(head)
    {
        // if head = NULL
    if (head == null)
        return;
   
    // recursively traverse the remaining nodes
    sumOfLastN_Nodes(head.next);
   
    // if node count 'n' is greater than 0
    if (n > 0)
    {
   
        // accumulate sum
        sum = sum + head.data;
   
        // reduce node count 'n' by 1
        --n;
    }
    }
      
    // utility function to find the sum of last 'n' nodes
    function sumOfLastN_NodesUtil(head,n)
    {
        // if n == 0
    if (n <= 0)
        return 0;
   
    sum = 0;
   
    // find the sum of last 'n' nodes
    sumOfLastN_Nodes(head);
   
    // required sum
    return sum;
    }
      
    // Driver Code
    head = null;
   
    // create linked list 10.6.8.4.12
    push(head, 12);
    push(head, 4);
    push(head, 8);
    push(head, 6);
    push(head, 10);
   
    n = 2;
    document.write("Sum of last " + n +
                     " nodes = " +
                     sumOfLastN_NodesUtil(head, n));
      
  
// This code is contributed by unknown2108

输出：

Sum of last 2 nodes = 16

时间复杂度： O(n)，其中 n 是链表中的节点数。
辅助空间： O(n)，如果正在考虑系统调用堆栈。

方法2（使用用户定义堆栈的迭代方法）
这是本文方法 1中解释的递归方法的迭代过程。从左到右遍历节点。遍历时将节点推送到用户定义的堆栈。然后从堆栈中弹出前n 个值并添加它们。

Javascript

// Javascript implementation to find the sum of last
// 'n' nodes of the Linked List
      
    /* A Linked list node */
    class Node
    {
        constructor()
        {
            let data,next;
        }
    }
      
    // function to insert a node at the
// beginning of the linked list
    function push(head_ref,new_data)
    {
        /* allocate node */
        let new_node = new Node();
        /* put in the data */
    new_node.data = new_data;
       
    /* link the old list to the new node */
    new_node.next = head_ref;
       
    /* move the head to point to the new node */
    head_ref = new_node;
    return head_ref;
    }
      
    // utility function to find the sum of last 'n' nodes
    function sumOfLastN_NodesUtil(head,n)
    {
        // if n == 0
    if (n <= 0)
        return 0;
   
    let st = [];
    let sum = 0;
   
    // traverses the list from left to right
    while (head != null)
    {
   
        // push the node's data onto the stack 'st'
        st.push(head.data);
   
        // move to next node
        head = head.next;
    }
   
    // pop 'n' nodes from 'st' and
    // add them
    while (n-- >0)
    {
        sum += st[st.length-1];
        st.pop();
    }
   
    // required sum
    return sum;
    }
      
    // Driver program to test above
    let head = null;
   
    // create linked list 10.6.8.4.12
    head = push(head, 12);
    head = push(head, 4);
    head = push(head, 8);
    head = push(head, 6);
    head = push(head, 10);
   
    let n = 2;
    document.write("Sum of last " + n+ " nodes = "
        + sumOfLastN_NodesUtil(head, n));
      
      
      
  
  
// This code is contributed by patel2127

输出：

Sum of last 2 nodes = 16

时间复杂度： O(n)，其中 n 是链表中的节点数。
辅助空间： O(n)，堆栈大小

方法3（反转链表）
以下是步骤：

1. 反转给定的链表。
2. 遍历反向链表的前n 个节点。
3. 遍历时添加它们。
4. 将链表反转回其原始顺序。
5. 返回相加的总和。

Javascript

// javascript implementation to find the sum of last
// 'n' nodes of the Linked List
  
/* A Linked list node */
     class Node {
            constructor() {
                this.data = 0;
                this.next = null;
            }
        }
var head; 
  
// function to insert a node at the
// beginning of the linked list
function push(head_ref , new_data)
{
    /* allocate node */
    var new_node = new Node();
      
    /* put in the data */
    new_node.data = new_data;
      
    /* link the old list to the new node */
    new_node.next = head_ref;
      
    /* move the head to point to the new node */
    head_ref = new_node;
    head=head_ref;
}
  
function reverseList(head_ref)
{
    var current, prev, next;
    current = head_ref;
    prev = null;
  
    while (current != null) 
    {
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
    }
  
    head_ref = prev;
    head = head_ref;
}
  
// utility function to find the sum of last 'n' nodes
function sumOfLastN_NodesUtil(n)
{
    // if n == 0
    if (n <= 0)
        return 0;
  
    // reverse the linked list
    reverseList(head);
  
    var sum = 0;
    var current = head;
  
    // traverse the 1st 'n' nodes of the reversed
    // linked list and add them
    while (current != null && n-- >0) 
    {                 
  
        // accumulate node's data to 'sum'
        sum += current.data;
  
        // move to next node
        current = current.next;
    }
  
    // reverse back the linked list
    reverseList(head);
  
    // required sum
    return sum;
}
  
// Driver code
   
  
    // create linked list 10.6.8.4.12
    push(head, 12);
    push(head, 4);
    push(head, 8);
    push(head, 6);
    push(head, 10);
  
    var n = 2;
    document.write("Sum of last " + n + " nodes = "
        + sumOfLastN_NodesUtil(n));
  
// This code contributed by umadevi9616

输出：

Sum of last 2 nodes = 16

时间复杂度： O(n)，其中 n 是链表中的节点数。
辅助空间： O(1)

方法四（使用链表的长度）
以下是步骤：

1. 计算给定链表的长度。让它成为len 。
2. 首先，从头开始遍历(len – n)个节点。
3. 然后遍历剩余的n 个节点，并在遍历时添加它们。
4. 返回相加的总和。

Javascript

  
// Javascript implementation to 
// find the sum of last 
// 'n' nodes of the Linked List 
    /* A Linked list node */
class Node {
    constructor() {
        this.data = 0;
        this.next = null;
    }
}
  
    var head;
  
    // function to insert a node at the
    // beginning of the linked list
    function push( head_ref , new_data) 
    {
        /* allocate node */
         new_node = new Node();
  
        /* put in the data */
        new_node.data = new_data;
  
        /* link the old list to
        the new node */
        new_node.next = head_ref;
  
        /* move the head to point
        to the new node */
        head_ref = new_node;
        head = head_ref;
    }
  
    // utility function to find 
    // the sum of last 'n' nodes
    function sumOfLastN_NodesUtil( head , n) 
    {
        // if n == 0
        if (n <= 0)
            return 0;
  
        var sum = 0, len = 0;
         temp = head;
  
        // calculate the length of the linked list
        while (temp != null) {
            len++;
            temp = temp.next;
        }
  
        // count of first (len - n) nodes
        var c = len - n;
        temp = head;
  
        // just traverse the 1st 'c' nodes
        while (temp != null && c-- > 0) {
            // move to next node
            temp = temp.next;
        }
  
        // now traverse the last 'n' 
        // nodes and add them
        while (temp != null) {
  
            // accumulate node's data to sum
            sum += temp.data;
  
            // move to next node
            temp = temp.next;
        }
  
        // required sum
        return sum;
    }
  
    // Driver code
      
  
        // create linked list 10.6.8.4.12
        push(head, 12);
        push(head, 4);
        push(head, 8);
        push(head, 6);
        push(head, 10);
  
        var n = 2;
        document.write("Sum of last " + n 
        + " nodes = " + sumOfLastN_NodesUtil(head, n));
  
// This code contributed by umadevi9616
  

输出：

Sum of last 2 nodes = 16

时间复杂度： O(n)，其中 n 是链表中的节点数。
辅助空间： O(1)

方法五（使用两个指针需要单次遍历）
维护两个指针——引用指针和主指针。初始化指向头的引用和主指针。首先，将引用指针从 head 移动到n 个节点，同时遍历累积节点的数据到某个变量，比如sum 。现在同时移动两个指针，直到引用指针到达列表的末尾，并在遍历时将所有节点的数据累积到引用指针指向的总和，并将所有节点的数据累积到主指针指向的某个变量，比如temp 。现在， (sum – temp)是最后n 个节点的所需总和。

Javascript

// Javascript implementation to find the sum of last
// 'n' nodes of the Linked List
      
    // Defining structure
    class Node
    {
        constructor()
        {
            let node,next;
        }
    }
      
    let head;
      
    function printList(start)
    {
        let temp = start;
        while (temp != null)
        {
            document.write(temp.data + " ");
            temp = temp.next;
        }
        document.write("<br>");
    }
      
    // Push function
    function push(start,info)
    {
        // Allocating node
        let node = new Node();
   
        // Info into node
        node.data = info;
   
        // Next of new node to head
        node.next = start;
   
        // head points to new node
        head = node;
    }
      
    function sumOfLastN_NodesUtil(head,n)
    {
        // if n == 0
        if (n <= 0)
            return 0;
   
        let sum = 0, temp = 0;
        let ref_ptr, main_ptr;
        ref_ptr = main_ptr = head;
   
        // traverse 1st 'n' nodes through 'ref_ptr' and
        // accumulate all node's data to 'sum'
        while (ref_ptr != null && (n--) > 0)
        {
            sum += ref_ptr.data;
   
            // move to next node
            ref_ptr = ref_ptr.next;
        }
   
        // traverse to the end of the linked list
        while (ref_ptr != null)
        {
   
            // accumulate all node's data to 'temp' pointed
            // by the 'main_ptr'
            temp += main_ptr.data;
   
            // accumulate all node's data to 'sum' pointed by
            // the 'ref_ptr'
            sum += ref_ptr.data;
   
            // move both the pointers to their respective
            // next nodes
            main_ptr = main_ptr.next;
            ref_ptr = ref_ptr.next;
        }
   
        // required sum
        return (sum - temp);
    }
      
    // Driver code
    head = null;
   
        // Adding elements to Linked List
        push(head, 12);
        push(head, 4);
        push(head, 8);
        push(head, 6);
        push(head, 10);
   
         
   
        let n = 2;
   
        document.write("Sum of last " + n +
                    " nodes = " + sumOfLastN_NodesUtil(head, n));
      
      
  
// This code is contributed by avanitrachhadiya2155

输出：

Sum of last 2 nodes = 16

时间复杂度： O(n)，其中 n 是链表中的节点数。
辅助空间： O(1)

有关详细信息，请参阅有关查找给定链表的最后 n 个节点的总和的完整文章！