给定链表中 K 个连续节点的最大总和

给定一个链表，任务是找到将链表的任意 k 个连续节点相加得到的最大和。

例子：

Input: 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> NULL, K = 5 
Output: 20 
Maximum sum is obtained by adding last 5 nodes

Input: 2 -> 5 -> 3 -> 6 -> 4 -> 1 -> 7 -> NULL, K = 4 
Output: 18 

方法：想法是使用大小为 k 的滑动窗口，跟踪当前窗口的总和并在需要时更新最大总和。为了实现滑动窗口，可以使用两个指针来表示起点和终点。在每个步骤中，首先从当前和中减去 start 指向的节点的值，并将 end 指向的节点的值添加到当前和中。将此总和与最大总和进行比较，并在需要时更新结果。开始和结束指针在每一步增加 1。

下面是上述方法的实现：

C++

// C++ implementation of the approach
#include 
using namespace std;
 
// Structure of a node
struct Node {
    int data;
    Node* next;
};
 
// Function to create new node
Node* newNode(int data)
{
    Node* node = new Node;
    node->next = NULL;
    node->data = data;
    return node;
}
 
// Function to return the maximum sum of
// k consecutive nodes
int findMaxSum(Node* head, int k)
{
    // To store current window sum
    int sum = 0;
 
    // To store maximum sum
    int maxSum = 0;
 
    // Pointer to the start of window
    Node* start = head;
 
    // Pointer to the end of window
    Node* end = head;
 
    int i;
 
    // Find the sum of first k nodes
    for (i = 0; i < k; i++) {
        sum += end->data;
        end = end->next;
    }
 
    maxSum = sum;
 
    // Move window by one step and
    // update sum. Node pointed by
    // start is excluded from current
    // window so subtract it. Node
    // pointed by end is added to
    // current window so add its value.
    while (end != NULL) {
 
        // Subtract the starting element
        // from previous window
        sum -= start->data;
        start = start->next;
 
        // Add the element next to the end
        // of previous window
        sum += end->data;
        end = end->next;
 
        // Update the maximum sum so far
        maxSum = max(maxSum, sum);
    }
 
    return maxSum;
}
 
// Driver code
int main()
{
    Node* head = newNode(1);
    head->next = newNode(2);
    head->next->next = newNode(3);
    head->next->next->next = newNode(4);
    head->next->next->next->next = newNode(5);
    head->next->next->next->next->next = newNode(6);
 
    int k = 5;
 
    cout << findMaxSum(head, k);
 
    return 0;
}

Java

// Java implementation of the approach
class GFG
{
 
// Structure of a node
static class Node
{
    int data;
    Node next;
};
 
// Function to create new node
static Node newNode(int data)
{
    Node node = new Node();
    node.next = null;
    node.data = data;
    return node;
}
 
// Function to return the maximum sum of
// k consecutive nodes
static int findMaxSum(Node head, int k)
{
    // To store current window sum
    int sum = 0;
 
    // To store maximum sum
    int maxSum = 0;
 
    // Pointer to the start of window
    Node start = head;
 
    // Pointer to the end of window
    Node end = head;
 
    int i;
 
    // Find the sum of first k nodes
    for (i = 0; i < k; i++)
    {
        sum += end.data;
        end = end.next;
    }
 
    maxSum = sum;
 
    // Move window by one step and
    // update sum. Node pointed by
    // start is excluded from current
    // window so subtract it. Node
    // pointed by end is added to
    // current window so add its value.
    while (end != null)
    {
 
        // Subtract the starting element
        // from previous window
        sum -= start.data;
        start = start.next;
 
        // Add the element next to the end
        // of previous window
        sum += end.data;
        end = end.next;
 
        // Update the maximum sum so far
        maxSum = Math.max(maxSum, sum);
    }
    return maxSum;
}
 
// Driver code
public static void main(String[] args)
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);
    head.next.next.next.next.next = newNode(6);
 
    int k = 5;
    System.out.print(findMaxSum(head, k));
}
}
 
// This code is contributed by PrinciRaj1992

Python3

# Python3 implementation of the approach
 
# Node of Linked List
class Node:
     
    def __init__(self, x):
         
        self.data = x
        self.next = None
 
# Function to return the maximum sum of
# k consecutive nodes
def findMaxSum(head, k):
     
    # To store current window sum
    sum = 0
 
    # To store maximum sum
    maxSum = 0
 
    # Pointer to the start of window
    start = head
 
    # Pointer to the end of window
    end = head
     
    # Find the sum of first k nodes
    for i in range(k):
        sum += end.data
        end = end.next
 
    maxSum = sum
 
    # Move window by one step and
    # update sum. Node pointed by
    # start is excluded from current
    # window so subtract it. Node
    # pointed by end is added to
    # current window so add its value.
    while (end != None):
 
        # Subtract the starting element
        # from previous window
        sum -= start.data
        start = start.next
 
        # Add the element next to the end
        # of previous window
        sum += end.data
        end = end.next
 
        # Update the maximum sum so far
        maxSum = max(maxSum, sum)
 
    return maxSum
 
# Driver code
if __name__ == '__main__':
     
    head = Node(1)
    head.next = Node(2)
    head.next.next = Node(3)
    head.next.next.next = Node(4)
    head.next.next.next.next = Node(5)
    head.next.next.next.next.next = Node(6)
 
    k = 5
 
    print(findMaxSum(head, k))
 
# This code is contributed by mohit kumar 29

C#

// C# implementation of the approach
using System;
 
class GFG
{
 
// Structure of a node
public class Node
{
    public int data;
    public Node next;
};
 
// Function to create new node
static Node newNode(int data)
{
    Node node = new Node();
    node.next = null;
    node.data = data;
    return node;
}
 
// Function to return the maximum sum of
// k consecutive nodes
static int findMaxSum(Node head, int k)
{
    // To store current window sum
    int sum = 0;
 
    // To store maximum sum
    int maxSum = 0;
 
    // Pointer to the start of window
    Node start = head;
 
    // Pointer to the end of window
    Node end = head;
 
    int i;
 
    // Find the sum of first k nodes
    for (i = 0; i < k; i++)
    {
        sum += end.data;
        end = end.next;
    }
 
    maxSum = sum;
 
    // Move window by one step and
    // update sum. Node pointed by
    // start is excluded from current
    // window so subtract it. Node
    // pointed by end is added to
    // current window so add its value.
    while (end != null)
    {
 
        // Subtract the starting element
        // from previous window
        sum -= start.data;
        start = start.next;
 
        // Add the element next to the end
        // of previous window
        sum += end.data;
        end = end.next;
 
        // Update the maximum sum so far
        maxSum = Math.Max(maxSum, sum);
    }
    return maxSum;
}
 
// Driver code
public static void Main(String[] args)
{
    Node head = newNode(1);
    head.next = newNode(2);
    head.next.next = newNode(3);
    head.next.next.next = newNode(4);
    head.next.next.next.next = newNode(5);
    head.next.next.next.next.next = newNode(6);
 
    int k = 5;
    Console.Write(findMaxSum(head, k));
}
}
 
// This code is contributed by Rajput-Ji

Javascript

 
// JavaScript implementation of the approach   
// Structure of a node
class Node {
    constructor(val) {
        this.data = val;
        this.next = null;
    }
}
 
    // Function to create new node
    function newNode(data) {
        var node = new Node();
        node.next = null;
        node.data = data;
        return node;
    }
 
    // Function to return the maximum sum of
    // k consecutive nodes
    function findMaxSum(head , k) {
        // To store current window sum
        var sum = 0;
 
        // To store maximum sum
        var maxSum = 0;
 
        // Pointer to the start of window
        var start = head;
 
        // Pointer to the end of window
        var end = head;
 
        var i;
 
        // Find the sum of first k nodes
        for (i = 0; i < k; i++) {
            sum += end.data;
            end = end.next;
        }
 
        maxSum = sum;
 
        // Move window by one step and
        // update sum. Node pointed by
        // start is excluded from current
        // window so subtract it. Node
        // pointed by end is added to
        // current window so add its value.
        while (end != null) {
 
            // Subtract the starting element
            // from previous window
            sum -= start.data;
            start = start.next;
 
            // Add the element next to the end
            // of previous window
            sum += end.data;
            end = end.next;
 
            // Update the maximum sum so far
            maxSum = Math.max(maxSum, sum);
        }
        return maxSum;
    }
 
    // Driver code
     
        var head = newNode(1);
        head.next = newNode(2);
        head.next.next = newNode(3);
        head.next.next.next = newNode(4);
        head.next.next.next.next = newNode(5);
        head.next.next.next.next.next = newNode(6);
 
        var k = 5;
        document.write(findMaxSum(head, k));
 
// This code contributed by aashish1995
 

输出：

20

时间复杂度： O(n)
辅助空间： O(1)

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。