Skip to content
Related Articles

Related Articles

Insert a node in Linked List before a given node
  • Difficulty Level : Basic
  • Last Updated : 12 May, 2021

Given a node of Linked List N and a value K, the task is to insert the node with value K in the linked list before the given node N.

Structure of the Node:

C++




// Structure of Node
struct Node {
    int data;
    Node* next;
 
    // Constructor of Node
    Node(int val, Node* link = 0)
        : data(val), next(link)
    {
    }
};

Java




// Structure of Node
public class Node
{
    public int data;
    public Node next;
   
    // Constructor of Node
    public Node(int val, Node link = null)
    {
        this.data = val;
        this.next = link;
    }
}
 
// This code is contributed by divyesh072019

Python3




# Structure of Node
class Node:
     
    # Constructor of Node
    def __init__(self, val, link = None):
         
        self.data = val
        self.next = link
         
# This code is contributed by pratham76

C#




// Structure of Node
public class Node
{
    public int data;
    public Node next;
   
    // Constructor of Node
    public Node(int val, Node link = null)
    {
        this.data = val;
        this.next = link;
    }
};
 
// This code is contributed by rutvik_56

Javascript




<script>
// Structure of Node
class Node {
    // Constructor of Node
    constructor(val, link = null) {
         this.data = val;
         this.next = link;
    }
}
 
 
// This code is contributed by gauravrajput1
</script>
Output: 
5 8 6

 

In the given problem there might be two cases:



  • Given node is the head node.
  • Given node is any valid node except the head.

When given Node is the Head Node:

The idea is to create a new node with the given value K. Then the next part of the new node will be updated with the pointer head. And finally, the head will be updated with the new node’s address. Below is the image of the same:

When given Node is any valid node except head node:

The simplest approach is to traverse the given linked list to search the previous node of the given node. Then, create the new node with the given value K.Now, update the next part of the new node with the address of the given node and the next part of the previous node with the address of the new node. Below is an illustration of the approach with the help of image:

Below is the implementation of the above approach:

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
struct Node {
    int data;
    Node* next;
 
    // Constructor of Node
    Node(int val, Node* link = 0)
        : data(val), next(link)
    {
    }
};
 
// Create a head node
Node* head = new Node(5);
 
// Function prints the linked list
// starting from the given node
void printList(Node* n)
{
    // Till n is not NULL
    while (n != NULL) {
 
        // Print the data
        cout << n->data << " ";
        n = n->next;
    }
}
 
// Function to add a node before the
// given node other than head node
Node* addBefore(Node* given_ptr, int val)
{
 
    // First check if the given pointer
    // is the address of head
    if (head == given_ptr) {
 
        // Create a new node
        Node* n = new Node(val);
 
        // Point to next to current head
        n->next = head;
 
        // Update the head pointer
        head = n;
        return n;
    }
 
    // Otherwise traverse the list to
    // find previous node of given node
    else {
 
        Node *p, *n = head;
 
        // This loop will return p with
        // previous pointer of given node
        for (n, p; n != given_ptr;
             p = n, n = n->next)
            ;
 
        // Create a new node
        Node* m = new Node(val);
 
        // Update the m->next
        m->next = p->next;
 
        // Update previous node's next
        p->next = m;
 
        return m;
    }
}
 
// Driver Code
int main()
{
    // Head Node
    head->next = new Node(6);
 
    // Function Call
    addBefore(head->next, 8);
 
    // Print the linked List
    printList(head);
}

Java




// Java program for the above approach
import java.util.*;
 
class GFG{
 
static class Node
{
    int data;
    Node next;
     
    // Constructor of Node
    Node(int val)
    {
        this.data = val;
        this.next = null;
    }
}
 
static Node head = new Node(5);
 
// Function prints the linked list
// starting from the given node
static void printList(Node n)
{
     
    // Till n is not null
    while (n != null)
    {
         
        // Print the data
        System.out.print(n.data + " ");
        n = n.next;
    }
}
 
// Function to add a node before the
// given node other than head node
static Node addBefore(Node given_ptr, int val)
{
     
    // First check if the given pointer
    // is the address of head
    if (head == given_ptr)
    {
         
        // Create a new node
        Node n = new Node(val);
 
        // Point to next to current head
        n.next = head;
 
        // Update the head pointer
        head = n;
        return n;
    }
 
    // Otherwise traverse the list to
    // find previous node of given node
    else
    {
        Node p = null;
 
        // This loop will return p with
        // previous pointer of given node
        for(Node n = head; n != given_ptr;
                 p = n, n = n.next);
 
        // Create a new node
        Node m = new Node(val);
 
        // Update the m.next
        m.next = p.next;
 
        // Update previous node's next
        p.next = m;
 
        return m;
    }
}
 
// Driver Code
public static void main(String[] args)
{
     
    // Head Node
    head.next = new Node(6);
 
    // Function Call
    addBefore(head.next, 8);
 
    // Print the linked List
    printList(head);
}
}
 
// This code is contributed by Amit Katiyar

Python3




# Python3 program for the above approach
class Node:
     
    # Constructor of Node
    def __init__(self, val, link = None):
        self.data = val
        self.next = link
 
# Create a head node
head = Node(5);
  
# Function prints the linked list
# starting from the given node
def printList(n):
 
    # Till n is not NULL
    while (n != None):
  
        # Print the data
        print(n.data, end = ' ')
        n = n.next;
  
# Function to add a node before the
# given node other than head node
def addBefore(given_ptr, val):
    global head
     
    # First check if the given pointer
    # is the address of head
    if (head == given_ptr):
  
        # Create a node
        n = Node(val);
  
        # Point to next to current head
        n.next = head;
  
        # Update the head pointer
        head = n;
        return n;
      
    # Otherwise traverse the list to
    # find previous node of given node
    else:
  
        p = None
        n = head;
  
        # This loop will return p with
        # previous pointer of given node
        while(n != given_ptr):
            p = n
            n = n.next
  
        # Create a node
        m = Node(val);
  
        # Update the m.next
        m.next = p.next;
  
        # Update previous node's next
        p.next = m;
  
        return m;
     
# Driver Code
if __name__=='__main__':
     
    # Head Node
    head.next = Node(6);
  
    # Function Call
    addBefore(head.next, 8);
  
    # Print the linked List
    printList(head);
 
    # This code is contibuted by rutvik_56

C#




// C# program for the
// above approach
using System;
class GFG{
 
class Node
{
  public int data;
  public Node next;
 
  // Constructor of Node
  public Node(int val)
  {
    this.data = val;
    this.next = null;
  }
}
 
static Node head = new Node(5);
 
// Function prints the linked list
// starting from the given node
static void printList(Node n)
{   
  // Till n is not null
  while (n != null)
  {
    // Print the data
    Console.Write(n.data + " ");
    n = n.next;
  }
}
 
// Function to add a node before the
// given node other than head node
static Node addBefore(Node given_ptr,
                      int val)
{   
  // First check if the given
  // pointer is the address of
  // head
  if (head == given_ptr)
  {
    // Create a new node
    Node n = new Node(val);
 
    // Point to next to current
    // head
    n.next = head;
 
    // Update the head pointer
    head = n;
    return n;
  }
 
  // Otherwise traverse the list
  // to find previous node of
  // given node
  else
  {
    Node p = null;
 
    // This loop will return p with
    // previous pointer of given node
    for(Node n = head; n != given_ptr;
        p = n, n = n.next);
 
    // Create a new node
    Node m = new Node(val);
 
    // Update the m.next
    m.next = p.next;
 
    // Update previous node's next
    p.next = m;
 
    return m;
  }
}
 
// Driver Code
public static void Main(String[] args)
{   
  // Head Node
  head.next = new Node(6);
 
  // Function Call
  addBefore(head.next, 8);
 
  // Print the linked List
  printList(head);
}
}
 
// This code is contributed by shikhasingrajput
Output: 
5 8 6

 

Time Complexity: O(N) 
Auxiliary Space: O(1)
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live and Geeks Classes Live USA

 

My Personal Notes arrow_drop_up
Recommended Articles
Page :