# 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

{
int data;
};
struct SingleLL
{
};
// Returns the new linked list
{
// Create memory of head and tail Nodes
struct SingleLL *sll = (struct SingleLL *) malloc(sizeof(struct SingleLL));
if (sll == NULL)
{
printf("Memory overflow\n");
}
else
{
}
return sll;
}
// Returns a new Node of linked list
{
// Create dynamic node
if (node == NULL)
{
printf("Memory overflow\n");
}
else
{
// Set initial node value
node->data = data;
node->next = NULL;
}
return node;
}
void addNode(struct SingleLL *sll, int data)
{
{
}
else
{
//Find last node
while (temp->next != NULL)
{
temp = temp->next;
}
// Append the node at last position
temp->next = node;
}
}
void display(struct SingleLL *sll)
{
{
return;
}
while (temp != NULL)
{
{
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)
{
{
return;
}
int result = auxiliary->data;
int sum = 0;
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
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
public int data;
{
this.data = data;
this.next = null;
}
};
public class SingleLL
{
public SingleLL()
{
}
{
{
}
else
{
//Find last node
while (temp.next != null)
{
temp = temp.next;
}
// Append the node at last position
temp.next = node;
}
}
public void display()
{
{
return;
}
while (temp != null)
{
{
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()
{
{
return;
}
int result = auxiliary.data;
int sum = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
public: int data;
{
this->data = data;
this->next = NULL;
}
};;
class SingleLL
{
SingleLL()
{
}
{
{
}
else
{
//Find last node
while (temp->next != NULL)
{
temp = temp->next;
}
// Append the node at last position
temp->next = node;
}
}
void display()
{
{
cout << "\n Empty linked list\n";
return;
}
while (temp != NULL)
{
{
cout << " →";
}
cout << " " << temp->data;
// Visit to next node
temp = temp->next;
}
cout << " → NULL\n";
}
// Finding the maximum contiguous sum in linked list
void maxConsecutiveSum()
{
{
return;
}
int result = auxiliary->data;
int sum = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
public int data;
{
this.data = data;
this.next = null;
}
};
public class SingleLL
{
public SingleLL()
{
}
{
{
}
else
{
//Find last node
while (temp.next != null)
{
temp = temp.next;
}
// Append the node at last position
temp.next = node;
}
}
public void display()
{
{
return;
}
while (temp != null)
{
{
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()
{
{
return;
}
int result = auxiliary.data;
int sum = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
public \$data;
public \$next;

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

function __construct()
{
}
{
{
}
else
{
//Find last node
while (\$temp->next != null)
{
\$temp = \$temp->next;
}
// Append the node at last position
\$temp->next = \$node;
}
}
public  function display()
{
{
return;
}
while (\$temp != null)
{
{
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()
{
{
return;
}
\$result = \$auxiliary->data;
\$sum = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
\$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
*/
{
constructor(data)
{
this.data = data;
this.next = null;
}
};
class SingleLL
{
constructor()
{
}
{
{
}
else
{
//Find last node
while (temp.next != null)
{
temp = temp.next;
}
// Append the node at last position
temp.next = node;
}
}
display()
{
{
return;
}
while (temp != null)
{
{
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()
{
{
return;
}
var result = auxiliary.data;
var sum = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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

def __init__(self, data) :
self.data = data
self.next = None

class SingleLL :

def __init__(self) :

else :
# Find last node
while (temp.next != None) :
temp = temp.next

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

def display(self) :
return

while (temp != None) :
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) :
return

result = auxiliary.data
sum = 0
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()
#   1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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

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

def initialize()
end

else
# Find last node
while (temp.next != nil)
temp = temp.next
end

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

end

def display()
return
end

while (temp != nil)
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()
return
end

result = auxiliary.data
sum = 0
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()
#   1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
def this(data: Int)
{
this(data, null);
}
};
{
def this()
{
this(null);
}
def addNode(data: Int): Unit = {
{
}
else
{
//Find last node
while (temp.next != null)
{
temp = temp.next;
}
// Append the node at last position
temp.next = node;
}
}
def display(): Unit = {
{
return;
}
while (temp != null)
{
{
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 = {
{
return;
}
var result: Int = auxiliary.data;
var sum: Int = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
var data: Int;
init(_ data: Int)
{
self.data = data;
self.next = nil;
}
};
class SingleLL
{
init()
{
}
{
{
}
else
{
//Find last node
while (temp!.next  != nil)
{
temp = temp!.next;
}
// Append the node at last position
temp!.next = node;
}
}
func display()
{
{
return;
}
while (temp  != nil)
{
{
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()
{
{
return;
}
var result: Int = auxiliary!.data;
var sum: Int = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
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
*/
{
var data: Int;
constructor(data: Int)
{
this.data = data;
this.next = null;
}
};
class SingleLL
{
constructor()
{
}
{
{
}
else
{
//Find last node
while (temp?.next != null)
{
temp = temp.next;
}
// Append the node at last position
temp?.next = node;
}
}
fun display(): Unit
{
{
return;
}
while (temp != null)
{
{
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
{
{
return;
}
var result: Int = auxiliary!!.data;
var sum: Int = 0;
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();
//  1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → 4  → NULL
sll.display();
sll.maxConsecutiveSum();
}``````

#### Output

`````` 1 → -3 → 5 → 2 → 1 → -4 → -2 → 3 → 4 → -1 → -7 → 4 → NULL
Max Consecutive Sum : 9``````

## Comment

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.