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







© 2021, kalkicode.com, All rights reserved