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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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 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
        
            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 */

chevron_right


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.



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.



Improved By : princiraj1992



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.