Find Maximum sum of k consecutive nodes in linked list

Here given code implementation process.

// C Program 
// Find Maximum sum of k consecutive nodes in linked list
#include <stdio.h>

#include <stdlib.h> //for malloc function

// Linked List LinkNode
struct LinkNode
{
	int data;
	struct LinkNode *next;
};
// Singly linked list 
struct SingleLL
{
	struct LinkNode *head;
	struct LinkNode *tail;
};
// Returns the new linked list
struct SingleLL *newLinkedList()
{
	// Create memory of head and tail Nodes
	struct SingleLL *sll = (struct SingleLL *) malloc(sizeof(struct SingleLL));
	if (sll == NULL)
	{
		printf("Memory overflow\n");
	}
	else
	{
		sll->head = NULL;
	}
	return sll;
}
// Returns a new Node of linked list
struct LinkNode *createLinkNode(int data)
{
	// Create dynamic node
	struct LinkNode *node = (struct LinkNode *) malloc(sizeof(struct LinkNode));
	if (node == NULL)
	{
		printf("Memory overflow\n");
	}
	else
	{
		// Set initial node value
		node->data = data;
		node->next = NULL;
	}
	return node;
}
// Add new Node at end of linked list 
void addNode(struct SingleLL *sll, int data)
{
	struct LinkNode *node = createLinkNode(data);
	if (sll->head == NULL)
	{
		sll->head = node;
	}
	else
	{
		struct LinkNode *temp = sll->head;
		// Find last node
		while (temp->next != NULL)
		{
			temp = temp->next;
		}
		// Append the node at last position
		temp->next = node;
	}
}
// Display linked list element
void display(struct SingleLL *sll)
{
	if (sll->head == NULL)
	{
		printf("\n Empty linked list\n");
		return;
	}
	struct LinkNode *temp = sll->head;
	// iterating linked list elements
	while (temp != NULL)
	{
		if (temp != sll->head)
		{
			printf(" →");
		}
		printf(" %d", temp->data);
		// Visit to next node
		temp = temp->next;
	}
	printf(" → NULL\n");
}
// Find the max sum of consecutive K nodes
void consecutiveKSum(struct SingleLL *sll, int k)
{
	if (sll->head == NULL || k < 1)
	{
		return;
	}
	struct LinkNode *auxiliary = sll->head;
	struct LinkNode *start = sll->head;
	int result = 0;
	int sum = 0;
	int counter = 1;
	// Execute linked list node
	while (auxiliary != NULL)
	{
		sum = sum + auxiliary->data;
		if (counter >= k)
		{
			if (counter == k)
			{
				// Get first pair of k nodes
				result = sum;
			}
			else
			{
				sum = sum - start->data;
				if (sum > result)
				{
					result = sum;
				}
				// Visit to next node
				start = start->next;
			}
		}
		// Visit to next node
		auxiliary = auxiliary->next;
		counter++;
	}
	if (counter <= k)
	{
		printf("\n %d Consecutive nodes are not exists", k);
	}
	else
	{
		// Display calculated result
		printf(" Consecutive %d-nodes max sum is : %d\n", k, result);
	}
}
int main()
{
	// Create a empty linked list
	struct SingleLL *sll = newLinkedList();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	addNode(sll, 7);
	addNode(sll, 2);
	addNode(sll, 3);
	addNode(sll, 4);
	addNode(sll, 8);
	addNode(sll, 6);
	addNode(sll, -2);
	addNode(sll, 12);
	addNode(sll, 4);
	display(sll);
	int k = 4;
	consecutiveKSum(sll, k);
	return 0;
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
/*
  Java Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	public int data;
	public LinkNode next;
	public LinkNode(int data)
	{
		this.data = data;
		this.next = null;
	}
};
public class SingleLL
{
	public LinkNode head;
	public SingleLL()
	{
		this.head = null;
	}
	//Add new Node at end of linked list 
	public void addNode(int data)
	{
		LinkNode node = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			LinkNode temp = this.head;
			//Find last node
			while (temp.next != null)
			{
				temp = temp.next;
			}
			// Append the node at last position
			temp.next = node;
		}
	}
	// Display linked list element
	public void display()
	{
		if (this.head == null)
		{
			System.out.print("\n Empty linked list\n");
			return;
		}
		LinkNode temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				System.out.print(" →");
			}
			System.out.print(" " + temp.data);
			// Visit to next node
			temp = temp.next;
		}
		System.out.print(" → NULL\n");
	}
	// Find the max sum of consecutive K nodes
	public void consecutiveKSum(int k)
	{
		if (this.head == null || k < 1)
		{
			return;
		}
		LinkNode auxiliary = this.head;
		LinkNode start = this.head;
		int result = 0;
		int sum = 0;
		int counter = 1;
		// Execute linked list node
		while (auxiliary != null)
		{
			sum = sum + auxiliary.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary.next;
			counter++;
		}
		if (counter <= k)
		{
			System.out.print("\n " + k + " Consecutive nodes are not exists");
		}
		else
		{
			// Display calculated result
			System.out.print(" Consecutive " + k + "-nodes max sum is : " + result + "\n");
		}
	}
	public static void main(String[] args)
	{
		SingleLL sll = new SingleLL();
		//  Constructed linked list
		//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
		sll.addNode(7);
		sll.addNode(2);
		sll.addNode(3);
		sll.addNode(4);
		sll.addNode(8);
		sll.addNode(6);
		sll.addNode(-2);
		sll.addNode(12);
		sll.addNode(4);
		sll.display();
		int k = 4;
		sll.consecutiveKSum(k);
	}
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
// Include header file
#include <iostream>

using namespace std;
/*
  C++ Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	public: int data;
	LinkNode *next;
	LinkNode(int data)
	{
		this->data = data;
		this->next = NULL;
	}
};;
class SingleLL
{
	public: LinkNode *head;
	SingleLL()
	{
		this->head = NULL;
	}
	//Add new Node at end of linked list
	void addNode(int data)
	{
		LinkNode *node = new LinkNode(data);
		if (this->head == NULL)
		{
			this->head = node;
		}
		else
		{
			LinkNode *temp = this->head;
			//Find last node
			while (temp->next != NULL)
			{
				temp = temp->next;
			}
			// Append the node at last position
			temp->next = node;
		}
	}
	// Display linked list element
	void display()
	{
		if (this->head == NULL)
		{
			cout << "\n Empty linked list\n";
			return;
		}
		LinkNode *temp = this->head;
		//iterating linked list elements
		while (temp != NULL)
		{
			if (temp != this->head)
			{
				cout << " →";
			}
			cout << " " << temp->data;
			// Visit to next node
			temp = temp->next;
		}
		cout << " → NULL\n";
	}
	// Find the max sum of consecutive K nodes
	void consecutiveKSum(int k)
	{
		if (this->head == NULL || k < 1)
		{
			return;
		}
		LinkNode *auxiliary = this->head;
		LinkNode *start = this->head;
		int result = 0;
		int sum = 0;
		int counter = 1;
		// Execute linked list node
		while (auxiliary != NULL)
		{
			sum = sum + auxiliary->data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start->data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start->next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary->next;
			counter++;
		}
		if (counter <= k)
		{
			cout << "\n " << k << " Consecutive nodes are not exists";
		}
		else
		{
			// Display calculated result
			cout << " Consecutive " << k << "-nodes max sum is : " << result << "\n";
		}
	}
};
int main()
{
	SingleLL sll = SingleLL();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7);
	sll.addNode(2);
	sll.addNode(3);
	sll.addNode(4);
	sll.addNode(8);
	sll.addNode(6);
	sll.addNode(-2);
	sll.addNode(12);
	sll.addNode(4);
	sll.display();
	int k = 4;
	sll.consecutiveKSum(k);
	return 0;
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
// Include namespace system
using System;
/*
  C# Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
public class LinkNode
{
	public int data;
	public LinkNode next;
	public LinkNode(int data)
	{
		this.data = data;
		this.next = null;
	}
};
public class SingleLL
{
	public LinkNode head;
	public SingleLL()
	{
		this.head = null;
	}
	//Add new Node at end of linked list
	public void addNode(int data)
	{
		LinkNode node = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			LinkNode temp = this.head;
			//Find last node
			while (temp.next != null)
			{
				temp = temp.next;
			}
			// Append the node at last position
			temp.next = node;
		}
	}
	// Display linked list element
	public void display()
	{
		if (this.head == null)
		{
			Console.Write("\n Empty linked list\n");
			return;
		}
		LinkNode temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				Console.Write(" →");
			}
			Console.Write(" " + temp.data);
			// Visit to next node
			temp = temp.next;
		}
		Console.Write(" → NULL\n");
	}
	// Find the max sum of consecutive K nodes
	public void consecutiveKSum(int k)
	{
		if (this.head == null || k < 1)
		{
			return;
		}
		LinkNode auxiliary = this.head;
		LinkNode start = this.head;
		int result = 0;
		int sum = 0;
		int counter = 1;
		// Execute linked list node
		while (auxiliary != null)
		{
			sum = sum + auxiliary.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary.next;
			counter++;
		}
		if (counter <= k)
		{
			Console.Write("\n " + k + " Consecutive nodes are not exists");
		}
		else
		{
			// Display calculated result
			Console.Write(" Consecutive " + k + "-nodes max sum is : " + result + "\n");
		}
	}
	public static void Main(String[] args)
	{
		SingleLL sll = new SingleLL();
		//  Constructed linked list
		//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
		sll.addNode(7);
		sll.addNode(2);
		sll.addNode(3);
		sll.addNode(4);
		sll.addNode(8);
		sll.addNode(6);
		sll.addNode(-2);
		sll.addNode(12);
		sll.addNode(4);
		sll.display();
		int k = 4;
		sll.consecutiveKSum(k);
	}
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
<?php
/*
  Php Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	public $data;
	public $next;

	function __construct($data)
	{
		$this->data = $data;
		$this->next = null;
	}
};
class SingleLL
{
	public $head;

	function __construct()
	{
		$this->head = null;
	}
	//Add new Node at end of linked list
	public	function addNode($data)
	{
		$node = new LinkNode($data);
		if ($this->head == null)
		{
			$this->head = $node;
		}
		else
		{
			$temp = $this->head;
			//Find last node
			while ($temp->next != null)
			{
				$temp = $temp->next;
			}
			// Append the node at last position
			$temp->next = $node;
		}
	}
	// Display linked list element
	public	function display()
	{
		if ($this->head == null)
		{
			echo "\n Empty linked list\n";
			return;
		}
		$temp = $this->head;
		//iterating linked list elements
		while ($temp != null)
		{
			if ($temp != $this->head)
			{
				echo " →";
			}
			echo " ". $temp->data;
			// Visit to next node
			$temp = $temp->next;
		}
		echo " → NULL\n";
	}
	// Find the max sum of consecutive K nodes
	public	function consecutiveKSum($k)
	{
		if ($this->head == null || $k < 1)
		{
			return;
		}
		$auxiliary = $this->head;
		$start = $this->head;
		$result = 0;
		$sum = 0;
		$counter = 1;
		// Execute linked list node
		while ($auxiliary != null)
		{
			$sum = $sum + $auxiliary->data;
			if ($counter >= $k)
			{
				if ($counter == $k)
				{
					// Get first pair of k nodes
					$result = $sum;
				}
				else
				{
					$sum = $sum - $start->data;
					if ($sum > $result)
					{
						$result = $sum;
					}
					// Visit to next node
					$start = $start->next;
				}
			}
			// Visit to next node
			$auxiliary = $auxiliary->next;
			$counter++;
		}
		if ($counter <= $k)
		{
			echo "\n ". $k ." Consecutive nodes are not exists";
		}
		else
		{
			// Display calculated result
			echo " Consecutive ". $k ."-nodes max sum is : ". $result ."\n";
		}
	}
}

function main()
{
	$sll = new SingleLL();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	$sll->addNode(7);
	$sll->addNode(2);
	$sll->addNode(3);
	$sll->addNode(4);
	$sll->addNode(8);
	$sll->addNode(6);
	$sll->addNode(-2);
	$sll->addNode(12);
	$sll->addNode(4);
	$sll->display();
	$k = 4;
	$sll->consecutiveKSum($k);
}
main();

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
/*
  Node Js Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	constructor(data)
	{
		this.data = data;
		this.next = null;
	}
};
class SingleLL
{
	constructor()
	{
		this.head = null;
	}
	//Add new Node at end of linked list
	addNode(data)
	{
		var node = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			var temp = this.head;
			//Find last node
			while (temp.next != null)
			{
				temp = temp.next;
			}
			// Append the node at last position
			temp.next = node;
		}
	}
	// Display linked list element
	display()
	{
		if (this.head == null)
		{
			process.stdout.write("\n Empty linked list\n");
			return;
		}
		var temp = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				process.stdout.write(" →");
			}
			process.stdout.write(" " + temp.data);
			// Visit to next node
			temp = temp.next;
		}
		process.stdout.write(" → NULL\n");
	}
	// Find the max sum of consecutive K nodes
	consecutiveKSum(k)
	{
		if (this.head == null || k < 1)
		{
			return;
		}
		var auxiliary = this.head;
		var start = this.head;
		var result = 0;
		var sum = 0;
		var counter = 1;
		// Execute linked list node
		while (auxiliary != null)
		{
			sum = sum + auxiliary.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary.next;
			counter++;
		}
		if (counter <= k)
		{
			process.stdout.write("\n " + k + " Consecutive nodes are not exists");
		}
		else
		{
			// Display calculated result
			process.stdout.write(" Consecutive " + k + "-nodes max sum is : " + result + "\n");
		}
	}
}

function main()
{
	var sll = new SingleLL();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7);
	sll.addNode(2);
	sll.addNode(3);
	sll.addNode(4);
	sll.addNode(8);
	sll.addNode(6);
	sll.addNode(-2);
	sll.addNode(12);
	sll.addNode(4);
	sll.display();
	var k = 4;
	sll.consecutiveKSum(k);
}
main();

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
#   Python 3 Program for
#   Maximum sum of K consecutive nodes in the given Linked List

#  Linked list node
class LinkNode :
	
	def __init__(self, data) :
		self.data = data
		self.next = None
	

class SingleLL :
	
	def __init__(self) :
		self.head = None
	
	# Add new Node at end of linked list 
	def addNode(self, data) :
		node = LinkNode(data)
		if (self.head == None) :
			self.head = node
		else :
			temp = self.head
			# Find last node
			while (temp.next != None) :
				temp = temp.next
			
			#  Append the node at last position
			temp.next = node
		
	
	#  Display linked list element
	def display(self) :
		if (self.head == None) :
			print("\n Empty linked list")
			return
		
		temp = self.head
		# iterating linked list elements
		while (temp != None) :
			if (temp != self.head) :
				print(" →", end = "")
			
			print("", temp.data, end = "")
			#  Visit to next node
			temp = temp.next
		
		print(" → NULL")
	
	#  Find the max sum of consecutive K nodes
	def consecutiveKSum(self, k) :
		if (self.head == None or k < 1) :
			return
		
		auxiliary = self.head
		start = self.head
		result = 0
		sum = 0
		counter = 1
		#  Execute linked list node
		while (auxiliary != None) :
			sum = sum + auxiliary.data
			if (counter >= k) :
				if (counter == k) :
					#  Get first pair of k nodes
					result = sum
				else :
					sum = sum - start.data
					if (sum > result) :
						result = sum
					
					#  Visit to next node
					start = start.next
				
			
			#  Visit to next node
			auxiliary = auxiliary.next
			counter += 1
		
		if (counter <= k) :
			print("\n ", k ," Consecutive nodes are not exists", end = "")
		else :
			#  Display calculated result
			print(" Consecutive ", k ,"-nodes max sum is : ", result )
		
	

def main() :
	sll = SingleLL()
	#   Constructed linked list
	#   7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7)
	sll.addNode(2)
	sll.addNode(3)
	sll.addNode(4)
	sll.addNode(8)
	sll.addNode(6)
	sll.addNode(-2)
	sll.addNode(12)
	sll.addNode(4)
	sll.display()
	k = 4
	sll.consecutiveKSum(k)

if __name__ == "__main__": main()

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive  4 -nodes max sum is :  24
#   Ruby Program for
#   Maximum sum of K consecutive nodes in the given Linked List

#  Linked list node
class LinkNode  
	# Define the accessor and reader of class LinkNode  
	attr_reader :data, :next
	attr_accessor :data, :next
 
	
	def initialize(data) 
		self.data = data
		self.next = nil
	end

end

class SingleLL  
	# Define the accessor and reader of class SingleLL  
	attr_reader :head
	attr_accessor :head
 
	
	def initialize() 
		self.head = nil
	end

	# Add new Node at end of linked list 
	def addNode(data) 
		node = LinkNode.new(data)
		if (self.head == nil) 
			self.head = node
		else 
			temp = self.head
			# Find last node
			while (temp.next != nil) 
				temp = temp.next
			end

			#  Append the node at last position
			temp.next = node
		end

	end

	#  Display linked list element
	def display() 
		if (self.head == nil) 
			print("\n Empty linked list\n")
			return
		end

		temp = self.head
		# iterating linked list elements
		while (temp != nil) 
			if (temp != self.head) 
				print(" →")
			end

			print(" ", temp.data)
			#  Visit to next node
			temp = temp.next
		end

		print(" → NULL\n")
	end

	#  Find the max sum of consecutive K nodes
	def consecutiveKSum(k) 
		if (self.head == nil || k < 1) 
			return
		end

		auxiliary = self.head
		start = self.head
		result = 0
		sum = 0
		counter = 1
		#  Execute linked list node
		while (auxiliary != nil) 
			sum = sum + auxiliary.data
			if (counter >= k) 
				if (counter == k) 
					#  Get first pair of k nodes
					result = sum
				else 
					sum = sum - start.data
					if (sum > result) 
						result = sum
					end

					#  Visit to next node
					start = start.next
				end

			end

			#  Visit to next node
			auxiliary = auxiliary.next
			counter += 1
		end

		if (counter <= k) 
			print("\n ", k ," Consecutive nodes are not exists")
		else 
			#  Display calculated result
			print(" Consecutive ", k ,"-nodes max sum is : ", result ,"\n")
		end

	end

end

def main() 
	sll = SingleLL.new()
	#   Constructed linked list
	#   7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7)
	sll.addNode(2)
	sll.addNode(3)
	sll.addNode(4)
	sll.addNode(8)
	sll.addNode(6)
	sll.addNode(-2)
	sll.addNode(12)
	sll.addNode(4)
	sll.display()
	k = 4
	sll.consecutiveKSum(k)
end

main()

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
/*
  Scala Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode(var data: Int , var next: LinkNode)
{
	def this(data: Int)
	{
		this(data, null);
	}
};
class SingleLL(var head: LinkNode)
{
	def this()
	{
		this(null);
	}
	//Add new Node at end of linked list
	def addNode(data: Int): Unit = {
		var node: LinkNode = new LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			var temp: LinkNode = this.head;
			//Find last node
			while (temp.next != null)
			{
				temp = temp.next;
			}
			// Append the node at last position
			temp.next = node;
		}
	}
	// Display linked list element
	def display(): Unit = {
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		var temp: LinkNode = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				print(" →");
			}
			print(" " + temp.data);
			// Visit to next node
			temp = temp.next;
		}
		print(" → NULL\n");
	}
	// Find the max sum of consecutive K nodes
	def consecutiveKSum(k: Int): Unit = {
		if (this.head == null || k < 1)
		{
			return;
		}
		var auxiliary: LinkNode = this.head;
		var start: LinkNode = this.head;
		var result: Int = 0;
		var sum: Int = 0;
		var counter: Int = 1;
		// Execute linked list node
		while (auxiliary != null)
		{
			sum = sum + auxiliary.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary.next;
			counter += 1;
		}
		if (counter <= k)
		{
			print("\n " + k + " Consecutive nodes are not exists");
		}
		else
		{
			// Display calculated result
			print(" Consecutive " + k + "-nodes max sum is : " + result + "\n");
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		var sll: SingleLL = new SingleLL();
		//  Constructed linked list
		//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
		sll.addNode(7);
		sll.addNode(2);
		sll.addNode(3);
		sll.addNode(4);
		sll.addNode(8);
		sll.addNode(6);
		sll.addNode(-2);
		sll.addNode(12);
		sll.addNode(4);
		sll.display();
		var k: Int = 4;
		sll.consecutiveKSum(k);
	}
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24
/*
  Swift 4 Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	var data: Int;
	var next: LinkNode? ;
	init(_ data: Int)
	{
		self.data = data;
		self.next = nil;
	}
};
class SingleLL
{
	var head: LinkNode? ;
	init()
	{
		self.head = nil;
	}
	//Add new Node at end of linked list
	func addNode(_ data: Int)
	{
		let node: LinkNode? = LinkNode(data);
		if (self.head == nil)
		{
			self.head = node;
		}
		else
		{
			var temp: LinkNode? = self.head;
			//Find last node
			while (temp!.next  != nil)
			{
				temp = temp!.next;
			}
			// Append the node at last position
			temp!.next = node;
		}
	}
	// Display linked list element
	func display()
	{
		if (self.head == nil)
		{
			print("\n Empty linked list");
			return;
		}
		var temp: LinkNode? = self.head;
		//iterating linked list elements
		while (temp  != nil)
		{
			if (!(temp === self.head))
			{
				print(" →", terminator: "");
			}
			print(" ", temp!.data, terminator: "");
			// Visit to next node
			temp = temp!.next;
		}
		print(" → NULL");
	}
	// Find the max sum of consecutive K nodes
	func consecutiveKSum(_ k: Int)
	{
		if (self.head == nil || k < 1)
		{
			return;
		}
		var auxiliary: LinkNode? = self.head;
		var start: LinkNode? = self.head;
		var result: Int = 0;
		var sum: Int = 0;
		var counter: Int = 1;
		// Execute linked list node
		while (auxiliary  != nil)
		{
			sum = sum + auxiliary!.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start!.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start!.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary!.next;
			counter += 1;
		}
		if (counter <= k)
		{
			print("\n", k ,"Consecutive nodes are not exists", terminator: "");
		}
		else
		{
			// Display calculated result
			print(" Consecutive \(k)-nodes max sum is : ", result );
		}
	}
}
func main()
{
	let sll: SingleLL = SingleLL();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7);
	sll.addNode(2);
	sll.addNode(3);
	sll.addNode(4);
	sll.addNode(8);
	sll.addNode(6);
	sll.addNode(-2);
	sll.addNode(12);
	sll.addNode(4);
	sll.display();
	let k: Int = 4;
	sll.consecutiveKSum(k);
}
main();

Output

  7 →  2 →  3 →  4 →  8 →  6 →  -2 →  12 →  4 → NULL
 Consecutive 4-nodes max sum is :  24
/*
  Kotlin Program for
  Maximum sum of K consecutive nodes in the given Linked List
*/
// Linked list node
class LinkNode
{
	var data: Int;
	var next: LinkNode ? ;
	constructor(data: Int)
	{
		this.data = data;
		this.next = null;
	}
};
class SingleLL
{
	var head: LinkNode ? ;
	constructor()
	{
		this.head = null;
	}
	//Add new Node at end of linked list
	fun addNode(data: Int): Unit
	{
		var node: LinkNode ? = LinkNode(data);
		if (this.head == null)
		{
			this.head = node;
		}
		else
		{
			var temp: LinkNode ? = this.head;
			//Find last node
			while (temp?.next != null)
			{
				temp = temp.next;
			}
			// Append the node at last position
			temp?.next = node;
		}
	}
	// Display linked list element
	fun display(): Unit
	{
		if (this.head == null)
		{
			print("\n Empty linked list\n");
			return;
		}
		var temp: LinkNode ? = this.head;
		//iterating linked list elements
		while (temp != null)
		{
			if (temp != this.head)
			{
				print(" →");
			}
			print(" " + temp.data);
			// Visit to next node
			temp = temp.next;
		}
		print(" → NULL\n");
	}
	// Find the max sum of consecutive K nodes
	fun consecutiveKSum(k: Int): Unit
	{
		if (this.head == null || k < 1)
		{
			return;
		}
		var auxiliary: LinkNode ? = this.head;
		var start: LinkNode ? = this.head;
		var result: Int = 0;
		var sum: Int = 0;
		var counter: Int = 1;
		// Execute linked list node
		while (auxiliary != null)
		{
			sum = sum + auxiliary.data;
			if (counter >= k)
			{
				if (counter == k)
				{
					// Get first pair of k nodes
					result = sum;
				}
				else
				{
					sum = sum - start!!.data;
					if (sum > result)
					{
						result = sum;
					}
					// Visit to next node
					start = start.next;
				}
			}
			// Visit to next node
			auxiliary = auxiliary.next;
			counter += 1;
		}
		if (counter <= k)
		{
			print("\n " + k + " Consecutive nodes are not exists");
		}
		else
		{
			// Display calculated result
			print(" Consecutive " + k + "-nodes max sum is : " + result + "\n");
		}
	}
}
fun main(args: Array < String > ): Unit
{
	var sll: SingleLL = SingleLL();
	//  Constructed linked list
	//  7 → -2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
	sll.addNode(7);
	sll.addNode(2);
	sll.addNode(3);
	sll.addNode(4);
	sll.addNode(8);
	sll.addNode(6);
	sll.addNode(-2);
	sll.addNode(12);
	sll.addNode(4);
	sll.display();
	var k: Int = 4;
	sll.consecutiveKSum(k);
}

Output

 7 → 2 → 3 → 4 → 8 → 6 → -2 → 12 → 4 → NULL
 Consecutive 4-nodes max sum is : 24


Please share your knowledge to improve code and content standard. Also submit your doubts, and test case. We improve by your feedback. We will try to resolve your query as soon as possible.

New Comment







© 2021, kalkicode.com, All rights reserved