Maximum sum contiguous nodes in the given linked list
Here given code implementation process.
// C Program
// Maximum sum contiguous nodes in the given 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");
}
// Finding the maximum contiguous sum in linked list
void maxConsecutiveSum(struct SingleLL *sll)
{
if (sll->head == NULL)
{
return;
}
struct LinkNode *auxiliary = sll->head;
int result = auxiliary->data;
int sum = 0;
// Execute linked list node
while (auxiliary != NULL)
{
sum = sum + auxiliary->data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary->next;
}
// Display calculated result
printf(" Max Consecutive Sum : %d\n", result);
}
int main()
{
// Create a empty linked list
struct SingleLL *sll = newLinkedList();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
addNode(sll, 1);
addNode(sll, -3);
addNode(sll, 5);
addNode(sll, 2);
addNode(sll, 1);
addNode(sll, -4);
addNode(sll, -2);
addNode(sll, 3);
addNode(sll, 4);
addNode(sll, -1);
addNode(sll, -7);
addNode(sll, 4);
display(sll);
maxConsecutiveSum(sll);
return 0;
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
/*
Java Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
public void maxConsecutiveSum()
{
if (this.head == null)
{
return;
}
LinkNode auxiliary = this.head;
int result = auxiliary.data;
int sum = 0;
// Execute linked list node
while (auxiliary != null)
{
sum = sum + auxiliary.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary.next;
}
// Display calculated result
System.out.print(" Max Consecutive Sum : " + result + "\n");
}
public static void main(String[] args)
{
SingleLL sll = new SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
// Include header file
#include <iostream>
using namespace std;
/*
C++ Program for
Maximum sum contiguous 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";
}
// Finding the maximum contiguous sum in linked list
void maxConsecutiveSum()
{
if (this->head == NULL)
{
return;
}
LinkNode *auxiliary = this->head;
int result = auxiliary->data;
int sum = 0;
// Execute linked list node
while (auxiliary != NULL)
{
sum = sum + auxiliary->data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary->next;
}
// Display calculated result
cout << " Max Consecutive Sum : " << result << "\n";
}
};
int main()
{
SingleLL sll = SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
return 0;
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
// Include namespace system
using System;
/*
C# Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
public void maxConsecutiveSum()
{
if (this.head == null)
{
return;
}
LinkNode auxiliary = this.head;
int result = auxiliary.data;
int sum = 0;
// Execute linked list node
while (auxiliary != null)
{
sum = sum + auxiliary.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary.next;
}
// Display calculated result
Console.Write(" Max Consecutive Sum : " + result + "\n");
}
public static void Main(String[] args)
{
SingleLL sll = new SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
<?php
/*
Php Program for
Maximum sum contiguous 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";
}
// Finding the maximum contiguous sum in linked list
public function maxConsecutiveSum()
{
if ($this->head == null)
{
return;
}
$auxiliary = $this->head;
$result = $auxiliary->data;
$sum = 0;
// Execute linked list node
while ($auxiliary != null)
{
$sum = $sum + $auxiliary->data;
if ($sum > $result)
{
// get new result
$result = $sum;
}
if ($sum < 0)
{
$sum = 0;
}
// Visit to next node
$auxiliary = $auxiliary->next;
}
// Display calculated result
echo " Max Consecutive Sum : ". $result ."\n";
}
}
function main()
{
$sll = new SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
$sll->addNode(1);
$sll->addNode(-3);
$sll->addNode(5);
$sll->addNode(2);
$sll->addNode(1);
$sll->addNode(-4);
$sll->addNode(-2);
$sll->addNode(3);
$sll->addNode(4);
$sll->addNode(-1);
$sll->addNode(-7);
$sll->addNode(4);
$sll->display();
$sll->maxConsecutiveSum();
}
main();
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
/*
Node Js Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
maxConsecutiveSum()
{
if (this.head == null)
{
return;
}
var auxiliary = this.head;
var result = auxiliary.data;
var sum = 0;
// Execute linked list node
while (auxiliary != null)
{
sum = sum + auxiliary.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary.next;
}
// Display calculated result
process.stdout.write(" Max Consecutive Sum : " + result + "\n");
}
}
function main()
{
var sll = new SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
main();
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
# Python 3 Program for
# Maximum sum contiguous 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")
# Finding the maximum contiguous sum in linked list
def maxConsecutiveSum(self) :
if (self.head == None) :
return
auxiliary = self.head
result = auxiliary.data
sum = 0
# Execute linked list node
while (auxiliary != None) :
sum = sum + auxiliary.data
if (sum > result) :
# get new result
result = sum
if (sum < 0) :
sum = 0
# Visit to next node
auxiliary = auxiliary.next
# Display calculated result
print(" Max Consecutive Sum : ", result )
def main() :
sll = SingleLL()
# Constructed linked list
# 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1)
sll.addNode(-3)
sll.addNode(5)
sll.addNode(2)
sll.addNode(1)
sll.addNode(-4)
sll.addNode(-2)
sll.addNode(3)
sll.addNode(4)
sll.addNode(-1)
sll.addNode(-7)
sll.addNode(4)
sll.display()
sll.maxConsecutiveSum()
if __name__ == "__main__": main()
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
# Ruby Program for
# Maximum sum contiguous 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
# Finding the maximum contiguous sum in linked list
def maxConsecutiveSum()
if (self.head == nil)
return
end
auxiliary = self.head
result = auxiliary.data
sum = 0
# Execute linked list node
while (auxiliary != nil)
sum = sum + auxiliary.data
if (sum > result)
# get new result
result = sum
end
if (sum < 0)
sum = 0
end
# Visit to next node
auxiliary = auxiliary.next
end
# Display calculated result
print(" Max Consecutive Sum : ", result ,"\n")
end
end
def main()
sll = SingleLL.new()
# Constructed linked list
# 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1)
sll.addNode(-3)
sll.addNode(5)
sll.addNode(2)
sll.addNode(1)
sll.addNode(-4)
sll.addNode(-2)
sll.addNode(3)
sll.addNode(4)
sll.addNode(-1)
sll.addNode(-7)
sll.addNode(4)
sll.display()
sll.maxConsecutiveSum()
end
main()
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
/*
Scala Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
def maxConsecutiveSum(): Unit = {
if (this.head == null)
{
return;
}
var auxiliary: LinkNode = this.head;
var result: Int = auxiliary.data;
var sum: Int = 0;
// Execute linked list node
while (auxiliary != null)
{
sum = sum + auxiliary.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary.next;
}
// Display calculated result
print(" Max Consecutive Sum : " + result + "\n");
}
}
object Main
{
def main(args: Array[String]): Unit = {
var sll: SingleLL = new SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
/*
Swift 4 Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
func maxConsecutiveSum()
{
if (self.head == nil)
{
return;
}
var auxiliary: LinkNode? = self.head;
var result: Int = auxiliary!.data;
var sum: Int = 0;
// Execute linked list node
while (auxiliary != nil)
{
sum = sum + auxiliary!.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary!.next;
}
// Display calculated result
print(" Max Consecutive Sum : ", result );
}
}
func main()
{
let sll: SingleLL = SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
main();
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
/*
Kotlin Program for
Maximum sum contiguous 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");
}
// Finding the maximum contiguous sum in linked list
fun maxConsecutiveSum(): Unit
{
if (this.head == null)
{
return;
}
var auxiliary: LinkNode ? = this.head;
var result: Int = auxiliary!!.data;
var sum: Int = 0;
// Execute linked list node
while (auxiliary != null)
{
sum = sum + auxiliary.data;
if (sum > result)
{
// get new result
result = sum;
}
if (sum < 0)
{
sum = 0;
}
// Visit to next node
auxiliary = auxiliary.next;
}
// Display calculated result
print(" Max Consecutive Sum : " + result + "\n");
}
}
fun main(args: Array<String> ): Unit
{
var sll: SingleLL = SingleLL();
// Constructed linked list
// 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4 → NULL
sll.addNode(1);
sll.addNode(-3);
sll.addNode(5);
sll.addNode(2);
sll.addNode(1);
sll.addNode(-4);
sll.addNode(-2);
sll.addNode(3);
sll.addNode(4);
sll.addNode(-1);
sll.addNode(-7);
sll.addNode(4);
sll.display();
sll.maxConsecutiveSum();
}
Output
1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9
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