Update adjacent nodes if the current node is zero in a Singly Linked List

Given a linked list. The task is to change the value of the previous and next node of a node to 0 if the current node is 0.

Examples:

Input :  2->3->4->5->0->9->0->9->NULL
Output : 2->3->4->0->0->0->0->0->NULL

Input : 0->2->3->4->0->0->NULL
Output : 0->0->3->0->0->0->NULL

Algorithm:

  1. First step is to create two pointers prev and curr.
    The prev will point to the previous node and curr to the current node. The reason for making use of prev is that we cannot backtrack in a singly linked list.
  2. if the first node is 0 then check if the next node is 0
    • If yes, then skip
    • else change the next node to -1.
  3. Start iterating through the nodes of the list.
    • if the current node is 0 and the variable temp is 0 then
      • set the previous node to -1.
      • set the temp variable to 1.
    • if the temp value is 1 and current node data is not 1 set the current node to -1
  4. Repeat step 3 until end of the list is reached.
  5. Traverse through the list and change the nodes with value -1 to 0.

Reason for making use of temp and -1 is that if we change the next node to 0 directly then this may lead to change the node after next node to 0 as a result of which the entire list may get changed to 0.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to update the adjacent
// nodes in a linked list
  
#include <bits/stdc++.h>
using namespace std;
  
// A linked list node
struct Node {
    int data;
    struct Node* next;
};
  
// Utility function to create a new Node
Node* newNode(int data)
{
    Node* temp = new Node;
    temp->data = data;
    temp->next = NULL;
  
    return temp;
}
  
// Function to display the linked list
void printList(Node* node)
{
    // iterate until end of the list is reached
    while (node != NULL) {
        cout << node->data << " ";
  
        node = node->next;
    }
}
  
// Function to udate the adjacent
// nodes to zero
void updateAdjacent(Node* head)
{
    // Pointer to point to
    // the previous node
    Node* prev = head;
  
    // Pointer to the
    // current node
    Node* curr = head->next;
  
    // If the first node is zero and the
    // second node is not zero then change 
    // the value to -1
    if (prev->data == 0 && curr->data != 0)
        curr->data = -1;
  
    // Temp variable to denote if the 
    // current node is zero then the next
    // node will be changed to zero
    int temp = 0;
  
    while (curr != NULL) {
  
        // if the temp variable is 1 and
        // current data is not zero
        if (temp == 1 && curr->data != 0) {
  
            // change the data to -1
            curr->data = -1;
            temp = 0;
        }
  
        // if the data is zero
        if (curr->data == 0) {
  
            // set the temp variable to 1
            temp = 1;
  
            // set the previous node data to -1
            prev->data = -1;
        }
  
        curr = curr->next;
        prev = prev->next;
    }
  
    curr = head;
  
    // change all the nodes with -1 to 0
    while (curr != NULL) {
        if (curr->data == -1)
            curr->data = 0;
  
        curr = curr->next;
    }
}
  
// Driver code
int main()
{
    // creating the linked list
    Node* head = newNode(2);
    head->next = newNode(3);
    head->next->next = newNode(4);
    head->next->next->next = newNode(5);
    head->next->next->next->next = newNode(0);
    head->next->next->next->next->next = newNode(9);
    head->next->next->next->next->next->next = newNode(0);
    head->next->next->next->next->next->next->next = newNode(9);
  
    updateAdjacent(head);
  
    printList(head);
  
    return 0;
}

chevron_right






                        filter_none









Java














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// Java program to update the adjacent 


// nodes in a linked list 


class GFG  


{ 


  


// A linked list node 


static class Node 


{ 


    int data; 


    Node next; 


} 


  


// Utility function to create a new Node 


static Node newNode(int data) 


{ 


    Node temp = new Node(); 


    temp.data = data; 


    temp.next = null; 


  


    return temp; 


} 


  


// Function to display the linked list 


static void printList(Node node) 


{ 


    // iterate until end of the list is reached 


    while (node != null)  


    { 


        System.out.print(node.data + " "); 


  


        node = node.next; 


    } 


} 


  


// Function to udate the adjacent 


// nodes to zero 


static void updateAdjacent(Node head) 


{ 


    // Pointer to point to 


    // the previous node 


    Node prev = head; 


  


    // Pointer to the 


    // current node 


    Node curr = head.next; 


  


    // If the first node is zero and the 


    // second node is not zero then change  


    // the value to -1 


    if (prev.data == 0 && curr.data != 0) 


        curr.data = -1; 


  


    // Temp variable to denote if the  


    // current node is zero then the next 


    // node will be changed to zero 


    int temp = 0; 


  


    while (curr != null)  


    { 


  


        // if the temp variable is 1 and 


        // current data is not zero 


        if (temp == 1 && curr.data != 0) 


        { 


  


            // change the data to -1 


            curr.data = -1; 


            temp = 0; 


        } 


  


        // if the data is zero 


        if (curr.data == 0)  


        { 


  


            // set the temp variable to 1 


            temp = 1; 


  


            // set the previous node data to -1 


            prev.data = -1; 


        } 


  


        curr = curr.next; 


        prev = prev.next; 


    } 


  


    curr = head; 


  


    // change all the nodes with -1 to 0 


    while (curr != null)  


    { 


        if (curr.data == -1) 


            curr.data = 0; 


  


        curr = curr.next; 


    } 


} 


  


// Driver code 


public static void main(String[] args)  


{ 


    // creating the linked list 


    Node head = newNode(2); 


    head.next = newNode(3); 


    head.next.next = newNode(4); 


    head.next.next.next = newNode(5); 


    head.next.next.next.next = newNode(0); 


    head.next.next.next.next.next = newNode(9); 


    head.next.next.next.next.next.next = newNode(0); 


    head.next.next.next.next.next.next.next = newNode(9); 


  


    updateAdjacent(head); 


  


    printList(head); 


} 


} 


  


/* This code contributed by PrinciRaj1992 */



















                        chevron_right







                        filter_none









Python3














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















# Python3 program to update the adjacent  


# nodes in a linked list  


  


# A linked list node  


class Node: 


      


    def __init__(self, data): 


        self.data = data 


        self.next = None


  


# Function to display the linked list  


def printList(node):  


  


    # iterate until end of the  


    # list is reached  


    while node != None:  


        print(node.data, end = " ")  


  


        node = node.next


  


# Function to udate the adjacent  


# nodes to zero  


def updateAdjacent(head):  


  


    # Pointer to point to  


    # the previous node  


    prev = head  


  


    # Pointer to the  


    # current node  


    curr = head.next


  


    # If the first node is zero and the  


    # second node is not zero then change  


    # the value to -1  


    if prev.data == 0 and curr.data != 0:  


        curr.data = -1


  


    # Temp variable to denote if the  


    # current node is zero then the next  


    # node will be changed to zero  


    temp = 0


  


    while curr != None:  


  


        # if the temp variable is 1 and  


        # current data is not zero  


        if temp == 1 and curr.data != 0:  


  


            # change the data to -1  


            curr.data = -1


            temp = 0


  


        # if the data is zero  


        if curr.data == 0:  


  


            # set the temp variable to 1  


            temp = 1


  


            # set the previous node data to -1  


            prev.data = -1


          


        curr = curr.next


        prev = prev.next


      


    curr = head  


  


    # change all the nodes with -1 to 0  


    while curr != None:  


        if curr.data == -1:  


            curr.data = 0


  


        curr = curr.next


      


# Driver Code 


if __name__ == "__main__":  


  


    # creating the linked list  


    head = Node(2)  


    head.next = Node(3)  


    head.next.next = Node(4)  


    head.next.next.next = Node(5)  


    head.next.next.next.next = Node(0)  


    head.next.next.next.next.next = Node(9)  


    head.next.next.next.next.next.next = Node(0)  


    head.next.next.next.next.next.next.next = Node(9)  


  


    updateAdjacent(head)  


  


    printList(head)  


  


# This code is contributed by Rituraj Jain 



















                        chevron_right







                        filter_none









C#














                                    filter_none




                                    edit

                                    close




                                    play_arrow




                                    link

                                    brightness_4

                                    code
                                




















// C# program to update the adjacent 


// nodes in a linked list 


using System; 


  


class GFG  


{ 


  


// A linked list node 


public class Node 


{ 


    public int data; 


    public Node next; 


} 


  


// Utility function to create a new Node 


static Node newNode(int data) 


{ 


    Node temp = new Node(); 


    temp.data = data; 


    temp.next = null; 


  


    return temp; 


} 


  


// Function to display the linked list 


static void printList(Node node) 


{ 


    // iterate until end of the list is reached 


    while (node != null)  


    { 


        Console.Write(node.data + " "); 


  


        node = node.next; 


    } 


} 


  


// Function to udate the adjacent 


// nodes to zero 


static void updateAdjacent(Node head) 


{ 


    // Pointer to point to 


    // the previous node 


    Node prev = head; 


  


    // Pointer to the 


    // current node 


    Node curr = head.next; 


  


    // If the first node is zero and the 


    // second node is not zero then change  


    // the value to -1 


    if (prev.data == 0 && curr.data != 0) 


        curr.data = -1; 


  


    // Temp variable to denote if the  


    // current node is zero then the next 


    // node will be changed to zero 


    int temp = 0; 


  


    while (curr != null)  


    { 


  


        // if the temp variable is 1 and 


        // current data is not zero 


        if (temp == 1 && curr.data != 0) 


        { 


  


            // change the data to -1 


            curr.data = -1; 


            temp = 0; 


        } 


  


        // if the data is zero 


        if (curr.data == 0)  


        { 


  


            // set the temp variable to 1 


            temp = 1; 


  


            // set the previous node data to -1 


            prev.data = -1; 


        } 


  


        curr = curr.next; 


        prev = prev.next; 


    } 


  


    curr = head; 


  


    // change all the nodes with -1 to 0 


    while (curr != null)  


    { 


        if (curr.data == -1) 


            curr.data = 0; 


  


        curr = curr.next; 


    } 


} 


  


// Driver code 


public static void Main(String[] args)  


{ 


    // creating the linked list 


    Node head = newNode(2); 


    head.next = newNode(3); 


    head.next.next = newNode(4); 


    head.next.next.next = newNode(5); 


    head.next.next.next.next = newNode(0); 


    head.next.next.next.next.next = newNode(9); 


    head.next.next.next.next.next.next = newNode(0); 


    head.next.next.next.next.next.next.next = newNode(9); 


  


    updateAdjacent(head); 


  


    printList(head); 


} 


} 


  


// This code contributed by Rajput-Ji 



















                        chevron_right







                        filter_none











Output:


2 3 4 0 0 0 0 0







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 Posts:
SanjayR
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.