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.

[sourcecode language=”Java” highlight=”109-116″]

// 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 continous 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);

}

}

[/sourcecode]

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.

## Recommended Posts:

- Given a linked list, reverse alternate nodes and append at the end
- Move all zeros to the front of the linked list
- Delete multiple occurrences of key in Linked list using double pointer
- Append odd position nodes in reverse at the end of even positioned nodes in a Linked List
- Partitioning a linked list around a given value and If we don't care about making the elements of the list "stable"
- Reverse first K elements of given linked list
- Pairwise swap elements of a given linked list
- Find unique elements in linked list
- Check if elements of Linked List are present in pair
- Count minimum frequency elements in a linked list
- Find smallest and largest elements in singly linked list
- Sort the linked list in the order of elements appearing in the array
- Replace even nodes of a doubly linked list with the elements of array
- Pairwise swap elements of a given linked list by changing links
- Find minimum and maximum elements in singly Circular Linked List

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.