Transfer the sum of all contiguous elements to right side zeros in a linked list

Here given code implementation process.

// C Program 
// Transfer the sum of all contiguous elements to right side zeros in a 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");
}
// Move the linked list to the right by the sum of the contiguous non-zero elements
void transform(struct SingleLL *sll)
{
	struct LinkNode *temp = sll->head;
	struct LinkNode *auxiliary = sll->head;
	sll->head = NULL;
	int sum = 0;
	while (temp != NULL)
	{
		if (temp->data != 0)
		{
			sum += temp->data;
			temp = temp->next;
		}
		else
		{
			temp->data = sum;
			if (sll->head == NULL)
			{
				// First resultant node get 
				sll->head = temp;
				auxiliary = temp;
				temp = temp->next;
			}
			else
			{
				// Add new sum result
				auxiliary->next = temp;
				auxiliary = temp;
				temp = temp->next;
			}
			// Avoid contiguous zero
			while (temp != NULL && temp->data == 0)
			{
				temp = temp->next;
			}
			sum = 0;
		}
	}
	if (sll->head == NULL)
	{
		// Linked list not converted because
		// When no zero exists in this linked list
		// Or all zero nodes exist in linked list
		sll->head = auxiliary;
	}
}
int main()
{
	// Create a empty linked lists
	struct SingleLL *sll1 = newLinkedList();
	struct SingleLL *sll2 = newLinkedList();
	struct SingleLL *sll3 = newLinkedList();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	addNode(sll1, 2);
	addNode(sll1, 5);
	addNode(sll1, 0);
	addNode(sll1, 8);
	addNode(sll1, 0);
	addNode(sll1, 4);
	addNode(sll1, 9);
	addNode(sll1, 7);
	addNode(sll1, 0);
	addNode(sll1, 1);
	printf(" Before Convert \n");
	display(sll1);
	transform(sll1);
	printf(" After Convert \n");
	display(sll1);
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	addNode(sll2, 1);
	addNode(sll2, 2);
	addNode(sll2, 0);
	addNode(sll2, 0);
	addNode(sll2, 0);
	addNode(sll2, 6);
	addNode(sll2, 0);
	printf(" Before Convert \n");
	display(sll2);
	transform(sll2);
	printf(" After Convert \n");
	display(sll2);
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	addNode(sll3, 1);
	addNode(sll3, 2);
	addNode(sll3, 3);
	printf(" Before Convert \n");
	display(sll3);
	transform(sll3);
	printf(" After Convert \n");
	display(sll3);
	return 0;
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
/*
  Java Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	public void transform()
	{
		LinkNode temp = this.head;
		LinkNode auxiliary = this.head;
		this.head = null;
		int sum = 0;
		while (temp != null)
		{
			if (temp.data != 0)
			{
				sum += temp.data;
				temp = temp.next;
			}
			else
			{
				temp.data = sum;
				if (this.head == null)
				{
					// First resultant node get 
					this.head = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				else
				{
					// Add new sum result
					auxiliary.next = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				// Avoid contiguous zero
				while (temp != null && temp.data == 0)
				{
					temp = temp.next;
				}
				sum = 0;
			}
		}
		if (this.head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this.head = auxiliary;
		}
	}
	public static void main(String[] args)
	{
		// Create a empty linked lists
		SingleLL sll1 = new SingleLL();
		SingleLL sll2 = new SingleLL();
		SingleLL sll3 = new SingleLL();
		//  Constructed first linked list
		//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
		sll1.addNode(2);
		sll1.addNode(5);
		sll1.addNode(0);
		sll1.addNode(8);
		sll1.addNode(0);
		sll1.addNode(4);
		sll1.addNode(9);
		sll1.addNode(7);
		sll1.addNode(0);
		sll1.addNode(1);
		System.out.print(" Before Convert \n");
		sll1.display();
		sll1.transform();
		System.out.print(" After Convert \n");
		sll1.display();
		// Constructed second linked list
		//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
		sll2.addNode(1);
		sll2.addNode(2);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(6);
		sll2.addNode(0);
		System.out.print(" Before Convert \n");
		sll2.display();
		sll2.transform();
		System.out.print(" After Convert \n");
		sll2.display();
		// Constructed third linked list
		//  1 → 2 → 3 → NULL
		sll3.addNode(1);
		sll3.addNode(2);
		sll3.addNode(3);
		System.out.print(" Before Convert \n");
		sll3.display();
		sll3.transform();
		System.out.print(" After Convert \n");
		sll3.display();
	}
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
// Include header file
#include <iostream>

using namespace std;
/*
  C++ Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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";
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	void transform()
	{
		LinkNode *temp = this->head;
		LinkNode *auxiliary = this->head;
		this->head = NULL;
		int sum = 0;
		while (temp != NULL)
		{
			if (temp->data != 0)
			{
				sum += temp->data;
				temp = temp->next;
			}
			else
			{
				temp->data = sum;
				if (this->head == NULL)
				{
					// First resultant node get
					this->head = temp;
					auxiliary = temp;
					temp = temp->next;
				}
				else
				{
					// Add new sum result
					auxiliary->next = temp;
					auxiliary = temp;
					temp = temp->next;
				}
				// Avoid contiguous zero
				while (temp != NULL && temp->data == 0)
				{
					temp = temp->next;
				}
				sum = 0;
			}
		}
		if (this->head == NULL)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this->head = auxiliary;
		}
	}
};
int main()
{
	// Create a empty linked lists
	SingleLL sll1 = SingleLL();
	SingleLL sll2 = SingleLL();
	SingleLL sll3 = SingleLL();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2);
	sll1.addNode(5);
	sll1.addNode(0);
	sll1.addNode(8);
	sll1.addNode(0);
	sll1.addNode(4);
	sll1.addNode(9);
	sll1.addNode(7);
	sll1.addNode(0);
	sll1.addNode(1);
	cout << " Before Convert \n";
	sll1.display();
	sll1.transform();
	cout << " After Convert \n";
	sll1.display();
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1);
	sll2.addNode(2);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(6);
	sll2.addNode(0);
	cout << " Before Convert \n";
	sll2.display();
	sll2.transform();
	cout << " After Convert \n";
	sll2.display();
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	sll3.addNode(1);
	sll3.addNode(2);
	sll3.addNode(3);
	cout << " Before Convert \n";
	sll3.display();
	sll3.transform();
	cout << " After Convert \n";
	sll3.display();
	return 0;
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
// Include namespace system
using System;
/*
  C# Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	public void transform()
	{
		LinkNode temp = this.head;
		LinkNode auxiliary = this.head;
		this.head = null;
		int sum = 0;
		while (temp != null)
		{
			if (temp.data != 0)
			{
				sum += temp.data;
				temp = temp.next;
			}
			else
			{
				temp.data = sum;
				if (this.head == null)
				{
					// First resultant node get
					this.head = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				else
				{
					// Add new sum result
					auxiliary.next = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				// Avoid contiguous zero
				while (temp != null && temp.data == 0)
				{
					temp = temp.next;
				}
				sum = 0;
			}
		}
		if (this.head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this.head = auxiliary;
		}
	}
	public static void Main(String[] args)
	{
		// Create a empty linked lists
		SingleLL sll1 = new SingleLL();
		SingleLL sll2 = new SingleLL();
		SingleLL sll3 = new SingleLL();
		//  Constructed first linked list
		//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
		sll1.addNode(2);
		sll1.addNode(5);
		sll1.addNode(0);
		sll1.addNode(8);
		sll1.addNode(0);
		sll1.addNode(4);
		sll1.addNode(9);
		sll1.addNode(7);
		sll1.addNode(0);
		sll1.addNode(1);
		Console.Write(" Before Convert \n");
		sll1.display();
		sll1.transform();
		Console.Write(" After Convert \n");
		sll1.display();
		// Constructed second linked list
		//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
		sll2.addNode(1);
		sll2.addNode(2);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(6);
		sll2.addNode(0);
		Console.Write(" Before Convert \n");
		sll2.display();
		sll2.transform();
		Console.Write(" After Convert \n");
		sll2.display();
		// Constructed third linked list
		//  1 → 2 → 3 → NULL
		sll3.addNode(1);
		sll3.addNode(2);
		sll3.addNode(3);
		Console.Write(" Before Convert \n");
		sll3.display();
		sll3.transform();
		Console.Write(" After Convert \n");
		sll3.display();
	}
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
<?php
/*
  Php Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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";
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	public	function transform()
	{
		$temp = $this->head;
		$auxiliary = $this->head;
		$this->head = null;
		$sum = 0;
		while ($temp != null)
		{
			if ($temp->data != 0)
			{
				$sum += $temp->data;
				$temp = $temp->next;
			}
			else
			{
				$temp->data = $sum;
				if ($this->head == null)
				{
					// First resultant node get
					$this->head = $temp;
					$auxiliary = $temp;
					$temp = $temp->next;
				}
				else
				{
					// Add new sum result
					$auxiliary->next = $temp;
					$auxiliary = $temp;
					$temp = $temp->next;
				}
				// Avoid contiguous zero
				while ($temp != null && $temp->data == 0)
				{
					$temp = $temp->next;
				}
				$sum = 0;
			}
		}
		if ($this->head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			$this->head = $auxiliary;
		}
	}
}

function main()
{
	// Create a empty linked lists
	$sll1 = new SingleLL();
	$sll2 = new SingleLL();
	$sll3 = new SingleLL();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	$sll1->addNode(2);
	$sll1->addNode(5);
	$sll1->addNode(0);
	$sll1->addNode(8);
	$sll1->addNode(0);
	$sll1->addNode(4);
	$sll1->addNode(9);
	$sll1->addNode(7);
	$sll1->addNode(0);
	$sll1->addNode(1);
	echo " Before Convert \n";
	$sll1->display();
	$sll1->transform();
	echo " After Convert \n";
	$sll1->display();
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	$sll2->addNode(1);
	$sll2->addNode(2);
	$sll2->addNode(0);
	$sll2->addNode(0);
	$sll2->addNode(0);
	$sll2->addNode(6);
	$sll2->addNode(0);
	echo " Before Convert \n";
	$sll2->display();
	$sll2->transform();
	echo " After Convert \n";
	$sll2->display();
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	$sll3->addNode(1);
	$sll3->addNode(2);
	$sll3->addNode(3);
	echo " Before Convert \n";
	$sll3->display();
	$sll3->transform();
	echo " After Convert \n";
	$sll3->display();
}
main();

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
/*
  Node Js Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	transform()
	{
		var temp = this.head;
		var auxiliary = this.head;
		this.head = null;
		var sum = 0;
		while (temp != null)
		{
			if (temp.data != 0)
			{
				sum += temp.data;
				temp = temp.next;
			}
			else
			{
				temp.data = sum;
				if (this.head == null)
				{
					// First resultant node get
					this.head = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				else
				{
					// Add new sum result
					auxiliary.next = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				// Avoid contiguous zero
				while (temp != null && temp.data == 0)
				{
					temp = temp.next;
				}
				sum = 0;
			}
		}
		if (this.head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this.head = auxiliary;
		}
	}
}

function main()
{
	// Create a empty linked lists
	var sll1 = new SingleLL();
	var sll2 = new SingleLL();
	var sll3 = new SingleLL();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2);
	sll1.addNode(5);
	sll1.addNode(0);
	sll1.addNode(8);
	sll1.addNode(0);
	sll1.addNode(4);
	sll1.addNode(9);
	sll1.addNode(7);
	sll1.addNode(0);
	sll1.addNode(1);
	process.stdout.write(" Before Convert \n");
	sll1.display();
	sll1.transform();
	process.stdout.write(" After Convert \n");
	sll1.display();
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1);
	sll2.addNode(2);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(6);
	sll2.addNode(0);
	process.stdout.write(" Before Convert \n");
	sll2.display();
	sll2.transform();
	process.stdout.write(" After Convert \n");
	sll2.display();
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	sll3.addNode(1);
	sll3.addNode(2);
	sll3.addNode(3);
	process.stdout.write(" Before Convert \n");
	sll3.display();
	sll3.transform();
	process.stdout.write(" After Convert \n");
	sll3.display();
}
main();

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
#   Python 3 Program for
#   Transfer the sum of all contiguous elements to right side zeros in a 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")
	
	#  Move the linked list to the right by the sum of the contiguous non-zero elements
	def transform(self) :
		temp = self.head
		auxiliary = self.head
		self.head = None
		sum = 0
		while (temp != None) :
			if (temp.data != 0) :
				sum += temp.data
				temp = temp.next
			else :
				temp.data = sum
				if (self.head == None) :
					#  First resultant node get 
					self.head = temp
					auxiliary = temp
					temp = temp.next
				else :
					#  Add new sum result
					auxiliary.next = temp
					auxiliary = temp
					temp = temp.next
				
				#  Avoid contiguous zero
				while (temp != None and temp.data == 0) :
					temp = temp.next
				
				sum = 0
			
		
		if (self.head == None) :
			#  Linked list not converted because
			#  When no zero exists in this linked list
			#  Or all zero nodes exist in linked list
			self.head = auxiliary
		
	

def main() :
	#  Create a empty linked lists
	sll1 = SingleLL()
	sll2 = SingleLL()
	sll3 = SingleLL()
	#   Constructed first linked list
	#   2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2)
	sll1.addNode(5)
	sll1.addNode(0)
	sll1.addNode(8)
	sll1.addNode(0)
	sll1.addNode(4)
	sll1.addNode(9)
	sll1.addNode(7)
	sll1.addNode(0)
	sll1.addNode(1)
	print(" Before Convert ")
	sll1.display()
	sll1.transform()
	print(" After Convert ")
	sll1.display()
	#  Constructed second linked list
	#   1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1)
	sll2.addNode(2)
	sll2.addNode(0)
	sll2.addNode(0)
	sll2.addNode(0)
	sll2.addNode(6)
	sll2.addNode(0)
	print(" Before Convert ")
	sll2.display()
	sll2.transform()
	print(" After Convert ")
	sll2.display()
	#  Constructed third linked list
	#   1 → 2 → 3 → NULL
	sll3.addNode(1)
	sll3.addNode(2)
	sll3.addNode(3)
	print(" Before Convert ")
	sll3.display()
	sll3.transform()
	print(" After Convert ")
	sll3.display()

if __name__ == "__main__": main()

Output

 Before Convert
  2 →  5 →  0 →  8 →  0 →  4 →  9 →  7 →  0 →  1 → NULL
 After Convert
  7 →  8 →  20 →  1 → NULL
 Before Convert
  1 →  2 →  0 →  0 →  0 →  6 →  0 → NULL
 After Convert
  3 →  6 → NULL
 Before Convert
  1 →  2 →  3 → NULL
 After Convert
  1 →  2 →  3 → NULL
#   Ruby Program for
#   Transfer the sum of all contiguous elements to right side zeros in a 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

	#  Move the linked list to the right by the sum of the contiguous non-zero elements
	def transform() 
		temp = self.head
		auxiliary = self.head
		self.head = nil
		sum = 0
		while (temp != nil) 
			if (temp.data != 0) 
				sum += temp.data
				temp = temp.next
			else 
				temp.data = sum
				if (self.head == nil) 
					#  First resultant node get 
					self.head = temp
					auxiliary = temp
					temp = temp.next
				else 
					#  Add new sum result
					auxiliary.next = temp
					auxiliary = temp
					temp = temp.next
				end

				#  Avoid contiguous zero
				while (temp != nil && temp.data == 0) 
					temp = temp.next
				end

				sum = 0
			end

		end

		if (self.head == nil) 
			#  Linked list not converted because
			#  When no zero exists in this linked list
			#  Or all zero nodes exist in linked list
			self.head = auxiliary
		end

	end

end

def main() 
	#  Create a empty linked lists
	sll1 = SingleLL.new()
	sll2 = SingleLL.new()
	sll3 = SingleLL.new()
	#   Constructed first linked list
	#   2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2)
	sll1.addNode(5)
	sll1.addNode(0)
	sll1.addNode(8)
	sll1.addNode(0)
	sll1.addNode(4)
	sll1.addNode(9)
	sll1.addNode(7)
	sll1.addNode(0)
	sll1.addNode(1)
	print(" Before Convert \n")
	sll1.display()
	sll1.transform()
	print(" After Convert \n")
	sll1.display()
	#  Constructed second linked list
	#   1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1)
	sll2.addNode(2)
	sll2.addNode(0)
	sll2.addNode(0)
	sll2.addNode(0)
	sll2.addNode(6)
	sll2.addNode(0)
	print(" Before Convert \n")
	sll2.display()
	sll2.transform()
	print(" After Convert \n")
	sll2.display()
	#  Constructed third linked list
	#   1 → 2 → 3 → NULL
	sll3.addNode(1)
	sll3.addNode(2)
	sll3.addNode(3)
	print(" Before Convert \n")
	sll3.display()
	sll3.transform()
	print(" After Convert \n")
	sll3.display()
end

main()

Output

 Before Convert 
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert 
 7 → 8 → 20 → 1 → NULL
 Before Convert 
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert 
 3 → 6 → NULL
 Before Convert 
 1 → 2 → 3 → NULL
 After Convert 
 1 → 2 → 3 → NULL
/*
  Scala Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	def transform(): Unit = {
		var temp: LinkNode = this.head;
		var auxiliary: LinkNode = this.head;
		this.head = null;
		var sum: Int = 0;
		while (temp != null)
		{
			if (temp.data != 0)
			{
				sum += temp.data;
				temp = temp.next;
			}
			else
			{
				temp.data = sum;
				if (this.head == null)
				{
					// First resultant node get
					this.head = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				else
				{
					// Add new sum result
					auxiliary.next = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				// Avoid contiguous zero
				while (temp != null && temp.data == 0)
				{
					temp = temp.next;
				}
				sum = 0;
			}
		}
		if (this.head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this.head = auxiliary;
		}
	}
}
object Main
{
	def main(args: Array[String]): Unit = {
		// Create a empty linked lists
		var sll1: SingleLL = new SingleLL();
		var sll2: SingleLL = new SingleLL();
		var sll3: SingleLL = new SingleLL();
		//  Constructed first linked list
		//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
		sll1.addNode(2);
		sll1.addNode(5);
		sll1.addNode(0);
		sll1.addNode(8);
		sll1.addNode(0);
		sll1.addNode(4);
		sll1.addNode(9);
		sll1.addNode(7);
		sll1.addNode(0);
		sll1.addNode(1);
		print(" Before Convert \n");
		sll1.display();
		sll1.transform();
		print(" After Convert \n");
		sll1.display();
		// Constructed second linked list
		//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
		sll2.addNode(1);
		sll2.addNode(2);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(0);
		sll2.addNode(6);
		sll2.addNode(0);
		print(" Before Convert \n");
		sll2.display();
		sll2.transform();
		print(" After Convert \n");
		sll2.display();
		// Constructed third linked list
		//  1 → 2 → 3 → NULL
		sll3.addNode(1);
		sll3.addNode(2);
		sll3.addNode(3);
		print(" Before Convert \n");
		sll3.display();
		sll3.transform();
		print(" After Convert \n");
		sll3.display();
	}
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL
/*
  Swift 4 Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	func transform()
	{
		var temp: LinkNode? = self.head;
		var auxiliary: LinkNode? = self.head;
		self.head = nil;
		var sum: Int = 0;
		while (temp  != nil)
		{
			if (temp!.data  != 0)
			{
				sum += temp!.data;
				temp = temp!.next;
			}
			else
			{
				temp!.data = sum;
				if (self.head == nil)
				{
					// First resultant node get
					self.head = temp;
					auxiliary = temp;
					temp = temp!.next;
				}
				else
				{
					// Add new sum result
					auxiliary!.next = temp;
					auxiliary = temp;
					temp = temp!.next;
				}
				// Avoid contiguous zero
				while (temp  != nil && temp!.data == 0)
				{
					temp = temp!.next;
				}
				sum = 0;
			}
		}
		if (self.head == nil)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			self.head = auxiliary;
		}
	}
}
func main()
{
	// Create a empty linked lists
	let sll1: SingleLL = SingleLL();
	let sll2: SingleLL = SingleLL();
	let sll3: SingleLL = SingleLL();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2);
	sll1.addNode(5);
	sll1.addNode(0);
	sll1.addNode(8);
	sll1.addNode(0);
	sll1.addNode(4);
	sll1.addNode(9);
	sll1.addNode(7);
	sll1.addNode(0);
	sll1.addNode(1);
	print(" Before Convert ");
	sll1.display();
	sll1.transform();
	print(" After Convert ");
	sll1.display();
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1);
	sll2.addNode(2);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(6);
	sll2.addNode(0);
	print(" Before Convert ");
	sll2.display();
	sll2.transform();
	print(" After Convert ");
	sll2.display();
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	sll3.addNode(1);
	sll3.addNode(2);
	sll3.addNode(3);
	print(" Before Convert ");
	sll3.display();
	sll3.transform();
	print(" After Convert ");
	sll3.display();
}
main();

Output

 Before Convert
  2 →  5 →  0 →  8 →  0 →  4 →  9 →  7 →  0 →  1 → NULL
 After Convert
  7 →  8 →  20 →  1 → NULL
 Before Convert
  1 →  2 →  0 →  0 →  0 →  6 →  0 → NULL
 After Convert
  3 →  6 → NULL
 Before Convert
  1 →  2 →  3 → NULL
 After Convert
  1 →  2 →  3 → NULL
/*
  Kotlin Program for
  Transfer the sum of all contiguous elements to right side zeros in a 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");
	}
	// Move the linked list to the right by the sum of the contiguous non-zero elements
	fun transform(): Unit
	{
		var temp: LinkNode ? = this.head;
		var auxiliary: LinkNode ? = this.head;
		this.head = null;
		var sum: Int = 0;
		while (temp != null)
		{
			if (temp.data != 0)
			{
				sum += temp.data;
				temp = temp.next;
			}
			else
			{
				temp.data = sum;
				if (this.head == null)
				{
					// First resultant node get
					this.head = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				else
				{
					// Add new sum result
					auxiliary?.next = temp;
					auxiliary = temp;
					temp = temp.next;
				}
				// Avoid contiguous zero
				while (temp != null && temp.data == 0)
				{
					temp = temp.next;
				}
				sum = 0;
			}
		}
		if (this.head == null)
		{
			// Linked list not converted because
			// When no zero exists in this linked list
			// Or all zero nodes exist in linked list
			this.head = auxiliary;
		}
	}
}
fun main(args: Array < String > ): Unit
{
	// Create a empty linked lists
	var sll1: SingleLL = SingleLL();
	var sll2: SingleLL = SingleLL();
	var sll3: SingleLL = SingleLL();
	//  Constructed first linked list
	//  2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 NULL
	sll1.addNode(2);
	sll1.addNode(5);
	sll1.addNode(0);
	sll1.addNode(8);
	sll1.addNode(0);
	sll1.addNode(4);
	sll1.addNode(9);
	sll1.addNode(7);
	sll1.addNode(0);
	sll1.addNode(1);
	print(" Before Convert \n");
	sll1.display();
	sll1.transform();
	print(" After Convert \n");
	sll1.display();
	// Constructed second linked list
	//  1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
	sll2.addNode(1);
	sll2.addNode(2);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(0);
	sll2.addNode(6);
	sll2.addNode(0);
	print(" Before Convert \n");
	sll2.display();
	sll2.transform();
	print(" After Convert \n");
	sll2.display();
	// Constructed third linked list
	//  1 → 2 → 3 → NULL
	sll3.addNode(1);
	sll3.addNode(2);
	sll3.addNode(3);
	print(" Before Convert \n");
	sll3.display();
	sll3.transform();
	print(" After Convert \n");
	sll3.display();
}

Output

 Before Convert
 2 → 5 → 0 → 8 → 0 → 4 → 9 → 7 → 0 → 1 → NULL
 After Convert
 7 → 8 → 20 → 1 → NULL
 Before Convert
 1 → 2 → 0 → 0 → 0 → 6 → 0 → NULL
 After Convert
 3 → 6 → NULL
 Before Convert
 1 → 2 → 3 → NULL
 After Convert
 1 → 2 → 3 → NULL


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