Skip to content
Related Articles

Related Articles

Double elements and append zeros in linked list
  • Difficulty Level : Medium
  • Last Updated : 01 Feb, 2021
GeeksforGeeks - Summer Carnival Banner

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 <bits/stdc++.h>
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
Previous
Ordered Prime Signature
Next

CSS | Positioning Elements
Recommended Articles
Page :
Given a linked list, reverse alternate nodes and append at the end
18, Feb 14
Move all zeros to the front of the linked list
01, Feb 18
Append odd position nodes in reverse at the end of even positioned nodes in a Linked List
02, Jan 19
Append the last M nodes to the beginning of the given linked list
06, Jan 20
XOR Linked List - Pairwise swap elements of a given linked list
18, Jan 21
Delete multiple occurrences of key in Linked list using double pointer
05, Jun 18
Difference between Singly linked list and Doubly linked list
07, Jan 19
XOR Linked List - A Memory Efficient Doubly Linked List | Set 1
23, May 11
Merge a linked list into another linked list at alternate positions
20, Aug 13
Convert singly linked list into circular linked list
22, Sep 17
Create new linked list from two given linked list with greater element at each node
22, May 19
Check if a linked list is Circular Linked List
10, Jun 16
Generate Linked List consisting of maximum difference of squares of pairs of nodes from given Linked List
29, Oct 20
XOR Linked List - Reverse a Linked List in groups of given size
17, Jan 21
XOR linked list- Remove first node of the linked list
18, Jan 21
Convert Singly Linked List to XOR Linked List
18, Jan 19
XOR Linked List – A Memory Efficient Doubly Linked List | Set 2
14, Jun 12
XOR Linked List: Remove last node of the Linked List
24, Feb 21
XOR linked list: Reverse last K nodes of a Linked List
05, Mar 21
Partitioning a linked list around a given value and If we don't care about making the elements of the list "stable"
22, May 17
Construct a Maximum Sum Linked List out of two Sorted Linked Lists having some Common nodes
28, Nov 14
Create a linked list from two linked lists by choosing max element at each position
20, May 19
Construct a Doubly linked linked list from 2D Matrix
16, Apr 20
Sublist Search (Search a linked list in another list)
18, Jan 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Dhiman Mayank
@Dhiman Mayank
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox