Find sum and product of divisible key in linked list
Here given code implementation process.
// C Program
// Find sum and product of divisible key in linked list
#include <stdio.h>
#include <stdlib.h> //for malloc function
//Linked List Node
struct Node
{
int data;
struct Node *next;
};
//Create a node of linked list
struct Node *create_node(int data)
{
//Create dynamic node
struct Node *node = (struct Node *) malloc(sizeof(struct Node));
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 add_node(struct Node **head, int data)
{
struct Node *node = create_node(data);
if ( *head == NULL)
{
*head = node;
}
else
{
struct Node *temp = *head;
//Find last node
while (temp->next != NULL)
{
temp = temp->next;
}
//Add node at last position
temp->next = node;
}
}
//Display linked list element
void display(struct Node *head)
{
if (head == NULL)
{
printf("\n Empty linked list\n");
return;
}
struct Node *temp = head;
//iterating linked list elements
while (temp != NULL)
{
if (temp != head)
{
printf(" →");
}
printf(" %d", temp->data);
//visit to next node
temp = temp->next;
}
printf(" → NULL\n");
}
//Calculate sum and product of nodes which is divisible by given key
void find_sum_product(struct Node *head, int key)
{
if (head == NULL)
{
printf("\n Empty linked List");
}
else
{
//Display linked list nodes
printf("\n Linked Linked \n");
display(head);
// Define usful resultant variable
int sum = 0;
int product = 1;
int find = 0;
// Get first node of linked list
struct Node *auxiliary = head;
// iterating linked list elements
while (auxiliary != NULL)
{
if (auxiliary->data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary->data;
//Calculate product
product *= auxiliary->data;
}
// Visit to next node
auxiliary = auxiliary->next;
}
//Display result
if (find == 1)
{
printf(" Given key : %d", key);
printf("\n Sum : %d", sum);
printf("\n Product : %d\n", product);
}
else
{
printf(" Given key [%d] not exist\n", key);
}
}
}
int main()
{
struct Node *head = NULL;
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
add_node( &head, 2);
add_node( &head, 9);
add_node( &head, 1);
add_node( &head, 5);
add_node( &head, 6);
add_node( &head, 4);
add_node( &head, 3);
add_node( &head, 7);
find_sum_product(head, 3);
return 0;
}
Output
Linked Linked
2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
// Java Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
public int data;
public Node next;
public Node(int data)
{
//Set node value
this.data = data;
this.next = null;
}
}
class MyLinkedList
{
public Node head;
public Node tail;
//Class constructor
public MyLinkedList()
{
this.head = null;
this.tail = null;
}
//insert node at last of linke list
public void add_node(int data)
{
//Create a node
Node node = new Node(data);
if (this.head == null)
{
//When linked list empty add first node
this.head = node;
this.tail = node;
}
else
{
//Add new node at end of linked list
this.tail.next = node;
this.tail = node;
}
}
//Display linked list element
public void display()
{
if (this.head == null)
{
System.out.print("\nEmpty linked list\n");
return;
}
Node temp = this.head;
System.out.print("Linked List : ");
//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");
}
//Calculate sum and product of nodes which is divisible by given key
public void find_sum_product(int key)
{
if (this.head == null)
{
System.out.print("\n Empty linked List");
}
else
{
//Display linked list nodes
System.out.print("\n Linked Linked \n");
this.display();
// Define usful resultant variable
int sum = 0;
int product = 1;
int find = 0;
// Get first node of linked list
Node auxiliary = this.head;
// iterating linked list elements
while (auxiliary != null)
{
if (auxiliary.data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary.data;
//Calculate product
product *= auxiliary.data;
}
// Visit to next node
auxiliary = auxiliary.next;
}
//Display result
if (find == 1)
{
System.out.print(" Given key : " + key);
System.out.print("\n Sum : " + sum);
System.out.print("\n Product : " + product + "\n");
}
else
{
System.out.print(" Given key [" + key + "] not exist\n");
}
}
}
public static void main(String[] args)
{
MyLinkedList obj = new MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
}
}
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
//Include header file
#include <iostream>
using namespace std;
// C++ Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
public: int data;
Node *next;
Node(int data)
{
//Set node value
this->data = data;
this->next = NULL;
}
};
class MyLinkedList
{
public: Node *head;
Node *tail;
//Class constructor
MyLinkedList()
{
this->head = NULL;
this->tail = NULL;
}
//insert node at last of linke list
void add_node(int data)
{
//Create a node
Node *node = new Node(data);
if (this->head == NULL)
{
//When linked list empty add first node
this->head = node;
this->tail = node;
}
else
{
//Add new node at end of linked list
this->tail->next = node;
this->tail = node;
}
}
//Display linked list element
void display()
{
if (this->head == NULL)
{
cout << "\nEmpty linked list\n";
return;
}
Node *temp = this->head;
cout << "Linked List : ";
//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";
}
//Calculate sum and product of nodes which is divisible by given key
void find_sum_product(int key)
{
if (this->head == NULL)
{
cout << "\n Empty linked List";
}
else
{
//Display linked list nodes
cout << "\n Linked Linked \n";
this->display();
// Define usful resultant variable
int sum = 0;
int product = 1;
int find = 0;
// Get first node of linked list
Node *auxiliary = this->head;
// iterating linked list elements
while (auxiliary != NULL)
{
if (auxiliary->data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary->data;
//Calculate product
product *= auxiliary->data;
}
// Visit to next node
auxiliary = auxiliary->next;
}
//Display result
if (find == 1)
{
cout << " Given key : " << key;
cout << "\n Sum : " << sum;
cout << "\n Product : " << product << "\n";
}
else
{
cout << " Given key [" << key << "] not exist\n";
}
}
}
};
int main()
{
MyLinkedList obj = MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
return 0;
}
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
//Include namespace system
using System;
// C# Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
public int data;
public Node next;
public Node(int data)
{
//Set node value
this.data = data;
this.next = null;
}
}
class MyLinkedList
{
public Node head;
public Node tail;
//Class constructor
public MyLinkedList()
{
this.head = null;
this.tail = null;
}
//insert node at last of linke list
public void add_node(int data)
{
//Create a node
Node node = new Node(data);
if (this.head == null)
{
//When linked list empty add first node
this.head = node;
this.tail = node;
}
else
{
//Add new node at end of linked list
this.tail.next = node;
this.tail = node;
}
}
//Display linked list element
public void display()
{
if (this.head == null)
{
Console.Write("\nEmpty linked list\n");
return;
}
Node temp = this.head;
Console.Write("Linked List : ");
//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");
}
//Calculate sum and product of nodes which is divisible by given key
public void find_sum_product(int key)
{
if (this.head == null)
{
Console.Write("\n Empty linked List");
}
else
{
//Display linked list nodes
Console.Write("\n Linked Linked \n");
this.display();
// Define usful resultant variable
int sum = 0;
int product = 1;
int find = 0;
// Get first node of linked list
Node auxiliary = this.head;
// iterating linked list elements
while (auxiliary != null)
{
if (auxiliary.data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary.data;
//Calculate product
product *= auxiliary.data;
}
// Visit to next node
auxiliary = auxiliary.next;
}
//Display result
if (find == 1)
{
Console.Write(" Given key : " + key);
Console.Write("\n Sum : " + sum);
Console.Write("\n Product : " + product + "\n");
}
else
{
Console.Write(" Given key [" + key + "] not exist\n");
}
}
}
public static void Main(String[] args)
{
MyLinkedList obj = new MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
}
}
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
<?php
// Php Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
public $data;
public $next;
function __construct($data)
{
//Set node value
$this->data = $data;
$this->next = null;
}
}
class MyLinkedList
{
public $head;
public $tail;
//Class constructor
function __construct()
{
$this->head = null;
$this->tail = null;
}
//insert node at last of linke list
public function add_node($data)
{
//Create a node
$node = new Node($data);
if ($this->head == null)
{
//When linked list empty add first node
$this->head = $node;
$this->tail = $node;
}
else
{
//Add new node at end of linked list
$this->tail->next = $node;
$this->tail = $node;
}
}
//Display linked list element
public function display()
{
if ($this->head == null)
{
echo "\nEmpty linked list\n";
return;
}
$temp = $this->head;
echo "Linked List : ";
//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";
}
//Calculate sum and product of nodes which is divisible by given key
public function find_sum_product($key)
{
if ($this->head == null)
{
echo "\n Empty linked List";
}
else
{
//Display linked list nodes
echo "\n Linked Linked \n";
$this->display();
// Define usful resultant variable
$sum = 0;
$product = 1;
$find = 0;
// Get first node of linked list
$auxiliary = $this->head;
// iterating linked list elements
while ($auxiliary != null)
{
if ($auxiliary->data % $key == 0)
{
// When node value is divisible by key
// Active the result status
$find = 1;
//Calculate the sum of node value
$sum += $auxiliary->data;
//Calculate product
$product *= $auxiliary->data;
}
// Visit to next node
$auxiliary = $auxiliary->next;
}
//Display result
if ($find == 1)
{
echo " Given key : ". $key;
echo "\n Sum : ". $sum;
echo "\n Product : ". $product ."\n";
}
else
{
echo " Given key [". $key ."] not exist\n";
}
}
}
}
function main()
{
$obj = new MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
$obj->add_node(2);
$obj->add_node(9);
$obj->add_node(1);
$obj->add_node(5);
$obj->add_node(6);
$obj->add_node(4);
$obj->add_node(3);
$obj->add_node(7);
$obj->find_sum_product(3);
}
main();
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
// Node Js Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
constructor(data)
{
//Set node value
this.data = data;
this.next = null;
}
}
class MyLinkedList
{
//Class constructor
constructor()
{
this.head = null;
this.tail = null;
}
//insert node at last of linke list
add_node(data)
{
//Create a node
var node = new Node(data);
if (this.head == null)
{
//When linked list empty add first node
this.head = node;
this.tail = node;
}
else
{
//Add new node at end of linked list
this.tail.next = node;
this.tail = node;
}
}
//Display linked list element
display()
{
if (this.head == null)
{
process.stdout.write("\nEmpty linked list\n");
return;
}
var temp = this.head;
process.stdout.write("Linked List : ");
//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");
}
//Calculate sum and product of nodes which is divisible by given key
find_sum_product(key)
{
if (this.head == null)
{
process.stdout.write("\n Empty linked List");
}
else
{
//Display linked list nodes
process.stdout.write("\n Linked Linked \n");
this.display();
// Define usful resultant variable
var sum = 0;
var product = 1;
var find = 0;
// Get first node of linked list
var auxiliary = this.head;
// iterating linked list elements
while (auxiliary != null)
{
if (auxiliary.data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary.data;
//Calculate product
product *= auxiliary.data;
}
// Visit to next node
auxiliary = auxiliary.next;
}
//Display result
if (find == 1)
{
process.stdout.write(" Given key : " + key);
process.stdout.write("\n Sum : " + sum);
process.stdout.write("\n Product : " + product + "\n");
}
else
{
process.stdout.write(" Given key [" + key + "] not exist\n");
}
}
}
}
function main()
{
var obj = new MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
}
main();
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
# Python 3 Program
# Find sum and product of divisible key in linked list
# Node of LinkedList
class Node :
def __init__(self, data) :
# Set node value
self.data = data
self.next = None
class MyLinkedList :
# Class constructor
def __init__(self) :
self.head = None
self.tail = None
# insert node at last of linke list
def add_node(self, data) :
# Create a node
node = Node(data)
if (self.head == None) :
# When linked list empty add first node
self.head = node
self.tail = node
else :
# Add new node at end of linked list
self.tail.next = node
self.tail = node
# Display linked list element
def display(self) :
if (self.head == None) :
print("\nEmpty linked list\n", end = "")
return
temp = self.head
print("Linked List : ", end = "")
# 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\n", end = "")
# Calculate sum and product of nodes which is divisible by given key
def find_sum_product(self, key) :
if (self.head == None) :
print("\n Empty linked List", end = "")
else :
# Display linked list nodes
print("\n Linked Linked \n", end = "")
self.display()
# Define usful resultant variable
sum = 0
product = 1
find = 0
# Get first node of linked list
auxiliary = self.head
# iterating linked list elements
while (auxiliary != None) :
if (auxiliary.data % key == 0) :
# When node value is divisible by key
# Active the result status
find = 1
# Calculate the sum of node value
sum += auxiliary.data
# Calculate product
product *= auxiliary.data
# Visit to next node
auxiliary = auxiliary.next
# Display result
if (find == 1) :
print(" Given key : ", key, end = "")
print("\n Sum : ", sum, end = "")
print("\n Product : ", product ,"\n", end = "")
else :
print(" Given key [", key ,"] not exist\n", end = "")
def main() :
obj = MyLinkedList()
# Add linked list node
# 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2)
obj.add_node(9)
obj.add_node(1)
obj.add_node(5)
obj.add_node(6)
obj.add_node(4)
obj.add_node(3)
obj.add_node(7)
obj.find_sum_product(3)
if __name__ == "__main__": main()
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
# Ruby Program
# Find sum and product of divisible key in linked list
# Node of LinkedList
class Node
# Define the accessor and reader of class Node
attr_reader :data, :next
attr_accessor :data, :next
def initialize(data)
# Set node value
self.data = data
self.next = nil
end
end
class MyLinkedList
# Define the accessor and reader of class MyLinkedList
attr_reader :head, :tail
attr_accessor :head, :tail
# Class constructor
def initialize()
self.head = nil
self.tail = nil
end
# insert node at last of linke list
def add_node(data)
# Create a node
node = Node.new(data)
if (self.head == nil)
# When linked list empty add first node
self.head = node
self.tail = node
else
# Add new node at end of linked list
self.tail.next = node
self.tail = node
end
end
# Display linked list element
def display()
if (self.head == nil)
print("\nEmpty linked list\n")
return
end
temp = self.head
print("Linked List : ")
# 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
# Calculate sum and product of nodes which is divisible by given key
def find_sum_product(key)
if (self.head == nil)
print("\n Empty linked List")
else
# Display linked list nodes
print("\n Linked Linked \n")
self.display()
# Define usful resultant variable
sum = 0
product = 1
find = 0
# Get first node of linked list
auxiliary = self.head
# iterating linked list elements
while (auxiliary != nil)
if (auxiliary.data % key == 0)
# When node value is divisible by key
# Active the result status
find = 1
# Calculate the sum of node value
sum += auxiliary.data
# Calculate product
product *= auxiliary.data
end
# Visit to next node
auxiliary = auxiliary.next
end
# Display result
if (find == 1)
print(" Given key : ", key)
print("\n Sum : ", sum)
print("\n Product : ", product ,"\n")
else
print(" Given key [", key ,"] not exist\n")
end
end
end
end
def main()
obj = MyLinkedList.new()
# Add linked list node
# 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2)
obj.add_node(9)
obj.add_node(1)
obj.add_node(5)
obj.add_node(6)
obj.add_node(4)
obj.add_node(3)
obj.add_node(7)
obj.find_sum_product(3)
end
main()
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
// Scala Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node(var data: Int,
var next: Node)
{
def this(data: Int)
{
this(data, null);
}
}
class MyLinkedList(var head: Node,
var tail: Node)
{
//Class constructor
def this()
{
this(null, null);
}
//insert node at last of linke list
def add_node(data: Int): Unit = {
//Create a node
var node: Node = new Node(data);
if (this.head == null)
{
//When linked list empty add first node
this.head = node;
this.tail = node;
}
else
{
//Add new node at end of linked list
this.tail.next = node;
this.tail = node;
}
}
//Display linked list element
def display(): Unit = {
if (this.head == null)
{
print("\nEmpty linked list\n");
return;
}
var temp: Node = this.head;
print("Linked List : ");
//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");
}
//Calculate sum and product of nodes which is divisible by given key
def find_sum_product(key: Int): Unit = {
if (this.head == null)
{
print("\n Empty linked List");
}
else
{
//Display linked list nodes
print("\n Linked Linked \n");
this.display();
// Define usful resultant variable
var sum: Int = 0;
var product: Int = 1;
var find: Int = 0;
// Get first node of linked list
var auxiliary: Node = this.head;
// iterating linked list elements
while (auxiliary != null)
{
if (auxiliary.data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary.data;
//Calculate product
product *= auxiliary.data;
}
// Visit to next node
auxiliary = auxiliary.next;
}
//Display result
if (find == 1)
{
print(" Given key : " + key);
print("\n Sum : " + sum);
print("\n Product : " + product + "\n");
}
else
{
print(" Given key [" + key + "] not exist\n");
}
}
}
}
object Main
{
def main(args: Array[String]): Unit = {
var obj: MyLinkedList = new MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
}
}
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
// Swift 4 Program
// Find sum and product of divisible key in linked list
//Node of LinkedList
class Node
{
var data: Int;
var next: Node? ;
init(_ data: Int)
{
//Set node value
self.data = data;
self.next = nil;
}
}
class MyLinkedList
{
var head: Node? ;
var tail: Node? ;
//Class constructor
init()
{
self.head = nil;
self.tail = nil;
}
//insert node at last of linke list
func add_node(_ data: Int)
{
//Create a node
let node: Node? = Node(data);
if (self.head == nil)
{
//When linked list empty add first node
self.head = node;
self.tail = node;
}
else
{
//Add new node at end of linked list
self.tail!.next = node;
self.tail = node;
}
}
//Display linked list element
func display()
{
if (self.head == nil)
{
print("\nEmpty linked list\n", terminator: "");
return;
}
var temp: Node? = self.head;
print("Linked List : ", terminator: "");
//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\n", terminator: "");
}
//Calculate sum and product of nodes which is divisible by given key
func find_sum_product(_ key: Int)
{
if (self.head == nil)
{
print("\n Empty linked List", terminator: "");
}
else
{
//Display linked list nodes
print("\n Linked Linked \n", terminator: "");
self.display();
// Define usful resultant variable
var sum: Int = 0;
var product: Int = 1;
var find: Int = 0;
// Get first node of linked list
var auxiliary: Node? = self.head;
// iterating linked list elements
while (auxiliary != nil)
{
if (auxiliary!.data % key == 0)
{
// When node value is divisible by key
// Active the result status
find = 1;
//Calculate the sum of node value
sum += auxiliary!.data;
//Calculate product
product *= auxiliary!.data;
}
// Visit to next node
auxiliary = auxiliary!.next;
}
//Display result
if (find == 1)
{
print(" Given key : ", key, terminator: "");
print("\n Sum : ", sum, terminator: "");
print("\n Product : ", product ,"\n", terminator: "");
}
else
{
print(" Given key [", key ,"]not exist\n", terminator: "");
}
}
}
}
func main()
{
let obj: MyLinkedList = MyLinkedList();
// Add linked list node
// 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
obj.add_node(2);
obj.add_node(9);
obj.add_node(1);
obj.add_node(5);
obj.add_node(6);
obj.add_node(4);
obj.add_node(3);
obj.add_node(7);
obj.find_sum_product(3);
}
main();
Output
Linked Linked
Linked List : 2 → 9 → 1 → 5 → 6 → 4 → 3 → 7 → NULL
Given key : 3
Sum : 18
Product : 162
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