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

Python3

# Python3 implementation to find the sum of
# last 'n' nodes of the Linked List
 
# Linked List node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
head = None
n = 0
sum = 0
 
# Function to insert a node at the
# beginning of the linked list
def push(head_ref, new_data):
    global head
     
    # Allocate node
    new_node = Node(0)
     
    # 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
def sumOfLastN_Nodes(head):
 
    global sum
    global n
 
    # if head = None
    if (head == None):
        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 = n - 1
     
# Utility function to find the sum of
# last 'n' nodes
def sumOfLastN_NodesUtil(head, n):
     
    global sum
     
    # 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 = None
 
# 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
print("Sum of last " , n ,
      " nodes = ",
      sumOfLastN_NodesUtil(head, n))
 
# This code is contributed by Arnab Kundu

输出：

Sum of last 2 nodes = 16

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

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

Python3

# Python3 implementation to find the sum of
# last 'n' nodes of the Linked List
 
# Linked List node
class Node:
    def __init__(self, data):
        self.data = data
        self.next = None
 
head = None
n = 0
sum = 0
 
# Function to insert a node at the
# beginning of the linked list
def push(head_ref, new_data):
    global head
     
    # Allocate node
    new_node = Node(0)
     
    # 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
def sumOfLastN_NodesUtil(head, n):
     
    global sum
     
    # if n == 0
    if (n <= 0):
        return 0
     
    st = []
    sum = 0
     
    # Traverses the list from left to right
    while (head != None):
         
        # Push the node's data onto the
        # stack 'st'
        st.append(head.data)
         
        # Move to next node
        head = head.next
     
    # Pop 'n' nodes from 'st' and
    # add them
    while (n):
        n -= 1
        sum += st[0]
        st.pop(0)
         
    # Required sum
    return sum
 
# Driver Code
head = None
 
# 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
print("Sum of last" , n ,
      "nodes =",
      sumOfLastN_NodesUtil(head, n))
# This code is contributed by shubhamsingh10

输出：

Sum of last 2 nodes = 16

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

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

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

Python3

# Python implementation to find the sum of last
# 'n' Nodes of the Linked List
''' A Linked list Node '''
 
# A Linked list Node
class Node:
 
    def __init__(self, x):
        self.data = x
        self.next = None
 
head = None
 
# Function to insert a Node at the
# beginning of the linked list
def push(head_ref, new_data):
   
    # Allocate Node
    new_Node = Node(new_data)
 
    # 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 the new Node
    head_ref = new_Node
    head = head_ref
    return head
 
def reverseList():
    global head;
    current, prev, next = None,
    None, None;
    current = head;
    prev = None;
 
    while (current != None):
        next = current.next;
        current.next = prev;
        prev = current;
        current = next;
 
    head = prev;
 
# Utility function to find the sum
# of last 'n' Nodes
def sumOfLastN_NodesUtil(n):
   
    # if n == 0
    if (n <= 0):
        return 0;
 
    # Reverse the linked list
    reverseList();
 
    sum = 0;
    current = head;
 
    # Traverse the 1st 'n' Nodes of the
    # reversed linked list and add them
    while (current != None and n > 0):
       
        # Accumulate Node's data to 'sum'
        sum += current.data;
 
        # Move to next Node
        current = current.next;
        n -= 1;
 
    # Reverse back the linked list
    reverseList();
 
    # Required sum
    return sum;
 
# Driver code
if __name__ == '__main__':
 
    # 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)
 
    n = 2;
    print("Sum of last ", n,
          " Nodes = ",
          sumOfLastN_NodesUtil(n));
# This code is contributed by Princi Singh

输出：

Sum of last 2 nodes = 16

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

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

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

Python3

# Python3 implementation to find the sum
# of last 'n' Nodes of the Linked List
 
# A Linked list Node
class Node:
     
    def __init__(self, x):       
        self.data = x
        self.next = None
         
head = None
 
# Function to insert a Node at the
# beginning of the linked list
def push(head_ref, new_data):
     
    # Allocate Node
    new_Node = Node(new_data)
 
    # 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
    return head
 
# Utility function to find the sum of
# last 'n' Nodes
def sumOfLastN_NodesUtil(head, n):
     
    # If n == 0
    if (n <= 0):
        return 0
 
    sum = 0
    len = 0
    temp = head
     
    # Calculate the length of the
    # linked list
    while (temp != None):
        len += 1
        temp = temp.next
 
    # Count of first (len - n) Nodes
    c = len - n
    temp = head
 
    # Just traverse the 1st 'c' Nodes
    while (temp != None and c > 0):
         
        # Move to next Node
        temp = temp.next
        c -= 1
 
    # Now traverse the last 'n' Nodes
    # and add them
    while (temp != None):
         
        # Accumulate Node's data to sum
        sum += temp.data
 
        # Move to next Node
        temp = temp.next
 
    # Required sum
    return sum
 
# Driver code
if __name__ == '__main__':
     
    # 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)
 
    n = 2
     
    print("Sum of last ", n, " Nodes = ",
          sumOfLastN_NodesUtil(head, n))
 
# This code is contributed by Princi Singh

输出：

Sum of last 2 nodes = 16

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

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

Python3

# Python3 implementation to find the sum
# of last 'n' nodes of the Linked List
class Node:
    def __init__(self, x):
        self.data = x
        self.next = None
 
# Function to insert a node at the
# beginning of the linked list
def push(head_ref,new_data):
   
    # Allocate node
    new_node = Node(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
def sumOfLastN_NodesUtil(head, n):
   
    # if n == 0
    if (n <= 0):
        return 0
 
    sum = 0
    temp = 0
    ref_ptr  = None
    main_ptr = None
    ref_ptr = main_ptr = head
 
    # Traverse 1st 'n' nodes through 'ref_ptr'
    # and accumulate all node's data to 'sum'
    while (ref_ptr != None and  n):
        sum += ref_ptr.data
 
        # Move to next node
        ref_ptr = ref_ptr.next
        n -= 1
 
    # Traverse to the end of the linked list
    while (ref_ptr != None):
 
        # 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
if __name__ == '__main__':
    head = None
 
    # 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)
 
    n = 2
    print("Sum of last ", n, " nodes = ",
          sumOfLastN_NodesUtil(head, n))
# This code is contributed by mohit kumar 29

输出：

Sum of last 2 nodes = 16

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

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