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
Recommended Articles
Page :