Java程序查找给定链表的最后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 个节点相加。总和可以累积在通过引用传递给函数或某个全局变量的某个变量中。

Java

// Java implementation to find the sum of
// last 'n' nodes of the Linked List
import java.util.*;
 
class GFG{
     
// A Linked list node
static class Node
{
    int data;
    Node next;
};
static Node head;
static int n, sum;
 
// Function to insert a node at the
// beginning of the linked list
static void push(Node head_ref,
                 int new_data)
{
    // Allocate node
    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;
}
 
// Function to recursively find the sum of last
// 'n' nodes of the given linked list
static void sumOfLastN_Nodes(Node 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
static int sumOfLastN_NodesUtil(Node head,
                                int 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
public static void main(String[] args)
{
    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;
    System.out.print("Sum of last " + n +
                     " nodes = " +
                     sumOfLastN_NodesUtil(head, n));
}
}
// This code is contributed by 29AjayKumar

输出：

Sum of last 2 nodes = 16

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

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

Java

// Java implementation to find the sum of last
// 'n' nodes of the Linked List
import java.util.*;
 
class GFG{
 
// A Linked list node
static class Node
{
    int data;
    Node next;
};
 
// Function to insert a node at the
// beginning of the linked list
static Node push(Node head_ref,
                 int new_data)
{
    // Allocate node
    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;
    return head_ref;
}
 
// Utility function to find the sum of
// last 'n' nodes
static int sumOfLastN_NodesUtil(Node head,
                                int n)
{
    // if n == 0
    if (n <= 0)
        return 0;
 
    Stack st = new Stack();
    int 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.peek();
        st.pop();
    }
 
    // Required sum
    return sum;
}
 
// Driver code
public static void main(String[] args)
{
    Node 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);
 
    int n = 2;
    System.out.print("Sum of last " + n +
                     " nodes = " +
                     sumOfLastN_NodesUtil(head, n));
}
}
// This code is contributed by 29AjayKumar

输出：

Sum of last 2 nodes = 16

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

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

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

Java

// Java implementation to find the sum of last
// 'n' nodes of the Linked List
import java.util.*;
 
class GFG{
     
// A Linked list node
static class Node
{
    int data;
    Node next;
};
static Node head;
 
// Function to insert a node at the
// beginning of the linked list
static void push(Node head_ref,
                 int new_data)
{
    // Allocate node
    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;
}
 
static void reverseList(Node head_ref)
{
    Node 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
static int sumOfLastN_NodesUtil(int n)
{
    // if n == 0
    if (n <= 0)
        return 0;
 
    // Reverse the linked list
    reverseList(head);
 
    int sum = 0;
    Node 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
public static void main(String[] args)
{
 
    // Create linked list 10.6.8.4.12
    push(head, 12);
    push(head, 4);
    push(head, 8);
    push(head, 6);
    push(head, 10);
 
    int n = 2;
    System.out.println("Sum of last " + n +
                       " nodes = " +
                       sumOfLastN_NodesUtil(n));
}
}
// This code is contributed by PrinciRaj1992

输出：

Sum of last 2 nodes = 16

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

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

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

Java

// Java implementation to find the sum of last
// 'n' nodes of the Linked List
class GFG{
 
// A Linked list node
static class Node
{
    int data;
    Node next;
};
static Node head;
 
// Function to insert a node at the
// beginning of the linked list
static void push(Node head_ref,
                 int new_data)
{
    // Allocate node
    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
static int sumOfLastN_NodesUtil(Node head,
                                int n)
{
    // if n == 0
    if (n <= 0)
        return 0;
 
    int sum = 0, len = 0;
    Node temp = head;
 
    // Calculate the length of the
    // linked list
    while (temp != null)
    {
        len++;
        temp = temp.next;
    }
 
    // Count of first (len - n) nodes
    int 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
public static void main(String[] args)
{
    // Create linked list 10.6.8.4.12
    push(head, 12);
    push(head, 4);
    push(head, 8);
    push(head, 6);
    push(head, 10);
 
    int n = 2;
    System.out.println("Sum of last " + n +
                       " nodes = " +
                       sumOfLastN_NodesUtil(head, n));
}
}
// This code is contributed by 29AjayKumar

输出：

Sum of last 2 nodes = 16

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

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

Java

// Java implementation to find the sum of last
// 'n' nodes of the Linked List
class GfG
{
    // Defining structure
    static class Node
    {
        int data;
        Node next;
    }
 
    static Node head;
 
    static void printList(Node start)
    {
        Node temp = start;
        while (temp != null)
        {
            System.out.print(temp.data + " ");
            temp = temp.next;
        }
        System.out.println();
    }
 
    // Push function
    static void push(Node start, int info)
    {
        // Allocating node
        Node 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;
    }
 
    private static int sumOfLastN_NodesUtil(Node head,
                                            int n)
    {
        // if n == 0
        if (n <= 0)
            return 0;
 
        int sum = 0, temp = 0;
        Node 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
    public static void main(String[] args)
    {
        head = null;
 
        // Adding elements to Linked List
        push(head, 12);
        push(head, 4);
        push(head, 8);
        push(head, 6);
        push(head, 10);
        printList(head);
        int n = 2;
        System.out.println("Sum of last " + n +
                           " nodes = " +
                           sumOfLastN_NodesUtil(head, n));
    }
}
// This code is contributed by shubham96301

输出：

Sum of last 2 nodes = 16

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

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