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