# Double elements and append zeros in linked list

Given a linked list with some two adjacent repeating nodes before a zero, task is to double the first and make next 0. After this, append all the zeros to tail.

Prerequisite: Basics of implementation of Singly Linked List

Examples :

```Input : 4 -> 4 -> 0 -> 2 -> 3 -> 4 ->
3 -> 3 -> 0 -> 4 ->
Output : 8-> 2-> 3-> 4-> 6-> 4-> 0->
0-> 0-> 0->

Explanation :
First, after doubling the first element and making
second element 0 before all zeros.
8 -> 0 -> 0 -> 2 -> 3 -> 4 -> 6 -> 0
-> 0 -> 4 ->
Next :
8 -> 6 -> 5 -> 6 -> 0 -> 0 -> 0 ->
0 -> 0 -> 0 -> 0 ->

Input : 0 -> 4 -> 4 -> 0 -> 3 -> 3 -> 0
-> 5 -> 0 -> 0 -> 6 ->
Output : 8 -> 6 -> 5 -> 6 -> 0 -> 0 -> 0
-> 0 -> 0 -> 0 -> 0 ->
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Traverse through the linked list, and wherever there are two adjacent same data of nodes before a 0 (e.g. 4 -> 4 -> 0), then, double first element and make another as 0 (e.g. 8 -> 0 -> 0 ->). Finally, traverse the linked list and linearly point all the zeros to tail.

## Java

 `// Java code to modify linked list ` `import` `java.util.*; ` ` `  `// Linked List Node ` `class` `Node ` `{ ` `    ``int` `data; ` `    ``Node next; ` ` `  `    ``// Constructor ` `    ``public` `Node(``int` `data) ` `    ``{ ` `        ``this``.data = data; ` `        ``next = ``null``; ` `    ``} ` `} ` ` `  `// Class ro perform operations ` `// on linked list ` `class` `GfG ` `{ ` `    ``// Recursive function to double the one of two ` `    ``// elements and make next one as 0, ` `    ``// which are equal before 0 ` `    ``public` `static` `void` `changeTwoBefore0(Node head) ` `    ``{ ` `        ``// there should be atleast three elements ` `        ``// to perform required operation ` `        ``if` `(head == ``null` `|| head.next == ``null` `|| ` `                         ``head.next.next == ``null``) ` `            ``return``; ` ` `  ` `  `        ``// when two continuous elements ` `        ``// are same ` `        ``if` `((head.data == head.next.data) && ` `                ``(head.next.next.data == ``0``)) ` `        ``{ ` ` `  `            ``int` `temp = head.data; ` `            ``head.data = ``2``*temp; ` `            ``head.next.data = ``0``; ` ` `  `            ``if` `(head.next.next.next != ``null``) ` `                ``head = head.next.next.next; ` `            ``else` `                ``return``; ` `        ``} ` `        ``else` `            ``head = head.next; ` ` `  `        ``// recursive call to changeTwoBefore0 ` `        ``// for next element ` `        ``changeTwoBefore0(head); ` `    ``} ` ` `  `    ``// function to append zeros at tail ` `    ``public` `static` `Node appendZero(Node head) ` `    ``{ ` `        ``if` `(head == ``null` `|| head.next == ``null``) ` `            ``return` `head; ` ` `  `        ``// Find tail node ` `        ``Node tail = head; ` `        ``while` `(tail.next != ``null``) ` `            ``tail = tail.next; ` `        ``Node  origTail = tail; ` ` `  `        ``// Case when starting nodes have 0 values ` `        ``// we need to change head in this case. ` `        ``Node curr = head; ` `        ``while` `(curr.next != ``null` `&& curr.data == ``0``) ` `        ``{ ` `            ``tail.next = curr; ` `            ``tail = curr; ` `            ``curr = curr.next; ` `        ``} ` `        ``head  = curr; ` ` `  `        ``// Now moving other 0s to end ` `        ``Node prev = curr; ` `        ``curr = curr.next; ` `         `  `        ``// We check until original tail ` `        ``while` `(curr != origTail) ` `        ``{ ` `            ``// If current data is 0, append ` `            ``// after tail and update tail. ` `            ``if` `(curr.data == ``0``) ` `            ``{ ` `                ``tail.next = curr; ` `                ``tail = curr; ` `                ``prev.next = curr.next; ` `            ``} ` `            ``else` `                ``prev = curr; ` `                 `  `            ``// We always move current         ` `            ``curr = curr.next; ` `        ``} ` `         `  `        ``// Finally making sure that linked ` `        ``// list is null terminated. ` `        ``tail.next = ``null``; ` ` `  `        ``return` `head; ` `    ``} ` `     `  `    ``public` `static` `Node doubleAndAppend0(Node head) ` `    ``{ ` `        ``// Change two same nodes before 0 ` `        ``changeTwoBefore0(head); ` `         `  `        ``// Move all 0s to end ` `        ``return` `appendZero(head); ` `    ``} ` ` `  `    ``// function to display the nodes ` `    ``public` `static` `void` `display(Node head) ` `    ``{ ` `        ``while` `(head != ``null``) ` `        ``{ ` `            ``System.out.print(head.data + ``" -> "``); ` `            ``head = head.next; ` `        ``} ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` ` `  `        ``Node head = ``new` `Node(``4``); ` `        ``head.next = ``new` `Node(``4``); ` `        ``head.next.next = ``new` `Node(``0``); ` `        ``head.next.next.next = ``new` `Node(``2``); ` `        ``head.next.next.next.next = ``new` `Node(``3``); ` `        ``head.next.next.next.next.next = ``new` `Node(``4``); ` `        ``head.next.next.next.next.next.next = ``new` `Node(``3``); ` `        ``head.next.next.next.next.next.next.next = ``new` `Node(``3``); ` `        ``head.next.next.next.next.next.next.next.next = ``new` `Node(``0``); ` `        ``head.next.next.next.next.next.next.next.next.next = ``new` `Node(``4``); ` ` `  `        ``System.out.println(``"Original linked list :"``); ` `        ``display(head); ` `   `  `        ``head = doubleAndAppend0(head); ` `  `  `        ``System.out.println(``"\nModified linked list :"``); ` `        ``display(head); ` `    ``} ` `} `

## Python3

 `# Python3 code to modify linked list ` ` `  `# Linked List Node ` `class` `Node: ` ` `  `    ``# Constructor ` `    ``def` `__init__(``self``, data): ` `     `  `        ``self``.data ``=` `data ` `        ``self``.``next` `=` `None` `     `  `# Recursive function to double the one of two ` `# elements and make next one as 0, ` `# which are equal before 0 ` `def` `changeTwoBefore0 (head): ` `     `  `    ``# there should be atleast three elements ` `    ``# to perform required operation ` `    ``if` `(head ``=``=` `None` `or` `head.``next` `=``=` `None` `or` `head.``next``.``next` `=``=` `None``): ` `        ``return` ` `  `    ``# when two continuous elements ` `    ``# are same ` `    ``if` `((head.data ``=``=` `head.``next``.data) ``and` `(head.``next``.``next``.data ``=``=` `0``)): ` ` `  `        ``temp ``=` `head.data ` `        ``head.data ``=` `2``*``temp ` `        ``head.``next``.data ``=` `0` ` `  `        ``if` `(head.``next``.``next``.``next` `!``=` `None``): ` `            ``head ``=` `head.``next``.``next``.``next` `        ``else``: ` `            ``return` `         `  `    ``else``: ` `        ``head ``=` `head.``next` ` `  `    ``# recursive call to changeTwoBefore0 ` `    ``# for next element ` `    ``changeTwoBefore0(head) ` `     `  `# function to append zeros at tail ` `def` `appendZero( head): ` `     `  `    ``if` `(head ``=``=` `None` `or` `head.``next` `=``=` `None``): ` `        ``return` `head ` ` `  `    ``# Find tail node ` `    ``tail ``=` `head ` `    ``while` `(tail.``next` `!``=` `None``): ` `        ``tail ``=` `tail.``next` `    ``origTail ``=` `tail ` ` `  `    ``# Case when starting nodes have 0 values ` `    ``# we need to change head in this case. ` `    ``curr ``=` `head ` `    ``while` `(curr.``next` `!``=` `None` `and` `curr.data ``=``=` `0``): ` `         `  `        ``tail.``next` `=` `curr ` `        ``tail ``=` `curr ` `        ``curr ``=` `curr.``next` `         `  `    ``head ``=` `curr ` ` `  `    ``# Now moving other 0s to end ` `    ``prev ``=` `curr ` `    ``curr ``=` `curr.``next` `     `  `    ``# We check until original tail ` `    ``while` `(curr !``=` `origTail): ` `         `  `        ``# If current data is 0, append ` `        ``# after tail and update tail. ` `        ``if` `(curr.data ``=``=` `0``): ` `             `  `            ``tail.``next` `=` `curr ` `            ``tail ``=` `curr ` `            ``prev.``next` `=` `curr.``next` `             `  `        ``else``: ` `            ``prev ``=` `curr ` `                 `  `        ``# We always move current      ` `        ``curr ``=` `curr.``next` `         `  `    ``# Finally making sure that linked ` `    ``# list is None terminated. ` `    ``tail.``next` `=` `None` ` `  `    ``return` `head ` `     `  `def` `doubleAndAppend0(head): ` `     `  `    ``# Change two same nodes before 0 ` `    ``changeTwoBefore0(head) ` `         `  `    ``# Move all 0s to end ` `    ``return` `appendZero(head) ` `     `  `# function to display the nodes ` `def` `display( head): ` `     `  `    ``while` `(head !``=` `None``): ` `         `  `        ``print``(head.data ,end ``=` `" -> "``) ` `        ``head ``=` `head.``next` ` `  `# Driver code ` ` `  `head ``=` `Node(``4``) ` `head.``next` `=` `Node(``4``) ` `head.``next``.``next` `=` `Node(``0``) ` `head.``next``.``next``.``next` `=` `Node(``2``) ` `head.``next``.``next``.``next``.``next` `=` `Node(``3``) ` `head.``next``.``next``.``next``.``next``.``next` `=` `Node(``4``) ` `head.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``3``) ` `head.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``3``) ` `head.``next``.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``0``) ` `head.``next``.``next``.``next``.``next``.``next``.``next``.``next``.``next``.``next` `=` `Node(``4``) ` ` `  `print``(``"Original linked list :"``) ` `display(head) ` `     `  `head ``=` `doubleAndAppend0(head) ` ` `  `print``(``"\nModified linked list :"``) ` `display(head) ` `     `  `# This code is contributed by Arnab Kundu `

## C#

 `// C# code to modify linked list  ` `using` `System; ` ` `  `// Linked List Node  ` `public` `class` `Node  ` `{  ` `    ``public` `int` `data;  ` `    ``public` `Node next;  ` ` `  `    ``// Constructor  ` `    ``public` `Node(``int` `data)  ` `    ``{  ` `        ``this``.data = data;  ` `        ``next = ``null``;  ` `    ``}  ` `}  ` ` `  `// Class ro perform operations  ` `// on linked list  ` `public` `class` `GfG  ` `{  ` `    ``// Recursive function to double the one of two  ` `    ``// elements and make next one as 0,  ` `    ``// which are equal before 0  ` `    ``public` `static` `void` `changeTwoBefore0(Node head)  ` `    ``{  ` `        ``// there should be atleast three elements  ` `        ``// to perform required operation  ` `        ``if` `(head == ``null` `|| head.next == ``null` `||  ` `                        ``head.next.next == ``null``)  ` `            ``return``;  ` ` `  ` `  `        ``// when two continuous elements  ` `        ``// are same  ` `        ``if` `((head.data == head.next.data) &&  ` `                ``(head.next.next.data == 0))  ` `        ``{  ` ` `  `            ``int` `temp = head.data;  ` `            ``head.data = 2*temp;  ` `            ``head.next.data = 0;  ` ` `  `            ``if` `(head.next.next.next != ``null``)  ` `                ``head = head.next.next.next;  ` `            ``else` `                ``return``;  ` `        ``}  ` `        ``else` `            ``head = head.next;  ` ` `  `        ``// recursive call to changeTwoBefore0  ` `        ``// for next element  ` `        ``changeTwoBefore0(head);  ` `    ``}  ` ` `  `    ``// function to append zeros at tail  ` `    ``public` `static` `Node appendZero(Node head)  ` `    ``{  ` `        ``if` `(head == ``null` `|| head.next == ``null``)  ` `            ``return` `head;  ` ` `  `        ``// Find tail node  ` `        ``Node tail = head;  ` `        ``while` `(tail.next != ``null``)  ` `            ``tail = tail.next;  ` `        ``Node origTail = tail;  ` ` `  `        ``// Case when starting nodes have 0 values  ` `        ``// we need to change head in this case.  ` `        ``Node curr = head;  ` `        ``while` `(curr.next != ``null` `&& curr.data == 0)  ` `        ``{  ` `            ``tail.next = curr;  ` `            ``tail = curr;  ` `            ``curr = curr.next;  ` `        ``}  ` `        ``head = curr;  ` ` `  `        ``// Now moving other 0s to end  ` `        ``Node prev = curr;  ` `        ``curr = curr.next;  ` `         `  `        ``// We check until original tail  ` `        ``while` `(curr != origTail)  ` `        ``{  ` `            ``// If current data is 0, append  ` `            ``// after tail and update tail.  ` `            ``if` `(curr.data == 0)  ` `            ``{  ` `                ``tail.next = curr;  ` `                ``tail = curr;  ` `                ``prev.next = curr.next;  ` `            ``}  ` `            ``else` `                ``prev = curr;  ` `                 `  `            ``// We always move current      ` `            ``curr = curr.next;  ` `        ``}  ` `         `  `        ``// Finally making sure that linked  ` `        ``// list is null terminated.  ` `        ``tail.next = ``null``;  ` ` `  `        ``return` `head;  ` `    ``}  ` `     `  `    ``public` `static` `Node doubleAndAppend0(Node head)  ` `    ``{  ` `        ``// Change two same nodes before 0  ` `        ``changeTwoBefore0(head);  ` `         `  `        ``// Move all 0s to end  ` `        ``return` `appendZero(head);  ` `    ``}  ` ` `  `    ``// function to display the nodes  ` `    ``public` `static` `void` `display(Node head)  ` `    ``{  ` `        ``while` `(head != ``null``)  ` `        ``{  ` `            ``Console.Write(head.data + ``" -> "``);  ` `            ``head = head.next;  ` `        ``}  ` `    ``}  ` ` `  `    ``// Driver code  ` `    ``public` `static` `void` `Main()  ` `    ``{  ` ` `  `        ``Node head = ``new` `Node(4);  ` `        ``head.next = ``new` `Node(4);  ` `        ``head.next.next = ``new` `Node(0);  ` `        ``head.next.next.next = ``new` `Node(2);  ` `        ``head.next.next.next.next = ``new` `Node(3);  ` `        ``head.next.next.next.next.next = ``new` `Node(4);  ` `        ``head.next.next.next.next.next.next = ``new` `Node(3);  ` `        ``head.next.next.next.next.next.next.next = ``new` `Node(3);  ` `        ``head.next.next.next.next.next.next.next.next = ``new` `Node(0);  ` `        ``head.next.next.next.next.next.next.next.next.next = ``new` `Node(4);  ` ` `  `        ``Console.Write(``"Original linked list :\n"``);  ` `        ``display(head);  ` `     `  `        ``head = doubleAndAppend0(head);  ` ` `  `        ``Console.WriteLine(``"\nModified linked list :"``);  ` `        ``display(head);  ` `    ``}  ` `}  ` ` `  `/* This code contributed by PrinciRaj1992 */`

Output :

```Original linked list :
4 -> 4 -> 0 -> 2 -> 3 -> 4 -> 3 -> 3 -> 0 -> 4 ->
8 -> 2 -> 3 -> 4 -> 6 -> 4 -> 0 -> 0 -> 0 -> 0 ->
```

Time complexity : O(n), where n is the number of nodes of linked list.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.