Related Articles
Double elements and append zeros in linked list
• Difficulty Level : Medium
• Last Updated : 01 Feb, 2021

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 ->```

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);``    ``}``}`

## C++

 `// C++ code to modify linked list``#include ``using` `namespace` `std;` `// Linked List Node``class` `Node {``public``:``    ``int` `data;``    ``Node* next;` `    ``// Constructor``public``:``    ``Node(``int` `dat)``    ``{``        ``data = dat;``        ``next = NULL;``    ``}``};` `// Recursive function to double the one of two``// elements and make next one as 0,``// which are equal before 0``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``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;``}` `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``void` `display(Node* head)``{``    ``while` `(head != NULL) {``        ``cout << head->data << ``" -> "``;``        ``head = head->next;``    ``}``}` `// Driver Code``int` `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);` `    ``cout << ``"Original linked list :"``;``    ``display(head);` `    ``head = doubleAndAppend0(head);` `    ``cout << ``"\nModified linked list :"``;``    ``display(head);``    ``return` `0;``}` `// contributed by ajaykr00kj`

## 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 ->
Modified linked list :
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