GeeksforGeeks App
Open App
Browser
Continue

Related Articles

We have introduced Linked Lists in the previous post. We also created a simple linked list with 3 nodes and discussed linked list traversal.
All programs discussed in this post consider the following representations of the linked list.

C++

 // A linked list node class Node {     public:    int data;     Node *next; }; // This code is contributed by rathbhupendra

C

 // A linked list nodestruct Node{  int data;  struct Node *next;};

Java

 // Linked List Classclass LinkedList{    Node head;  // head of list      /* Node Class */    class Node    {        int data;        Node next;                   // Constructor to create a new node        Node(int d) {data = d; next = null; }    }}

Python3

 # Node classclass Node:      # Function to initialize the node object    def __init__(self, data):        self.data = data  # Assign data        self.next = None  # Initialize next as null  # Linked List classclass LinkedList:        # Function to initialize the Linked List object    def __init__(self):         self.head = None

C#

 /* Linked list Node*/public class Node{    public int data;    public Node next;    public Node(int d) {data = d; next = null; }}

Javascript



DSA Self-paced course

In this post, methods to insert a new node in the linked list are discussed. A node can be added in three ways

• At the front of the linked list
• After a given node.
• At the end of the linked list.

Add a node at the front: (4 steps process)

Following are the 4 steps to add a node at the front.

C++

 // Given a reference (pointer to pointer) // to the head of a list and an int, // inserts a new node on the front of // the list.void push(Node** head_ref, int new_data) {         // 1. allocate node    Node* new_node = new Node();       // 2. put in the data    new_node->data = new_data;       // 3. Make next of new node as head    new_node->next = (*head_ref);       // 4. Move the head to point to     // the new node    (*head_ref) = new_node; }   // This code is contributed by rathbhupendra

C

 /* Given a reference (pointer to pointer) to the head of a list   and an int,  inserts a new node on the front of the list. */void push(struct Node** head_ref, int new_data){    /* 1. allocate node */    struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));       /* 2. put in the data  */    new_node->data  = new_data;       /* 3. Make next of new node as head */    new_node->next = (*head_ref);       /* 4. move the head to point to the new node */    (*head_ref)    = new_node;}

Java

 /* This function is in LinkedList class. Inserts a   new Node at front of the list. This method is    defined inside LinkedList class shown above */public void push(int new_data){    /* 1 & 2: Allocate the Node &              Put in the data*/    Node new_node = new Node(new_data);      /* 3. Make next of new Node as head */    new_node.next = head;      /* 4. Move the head to point to new Node */    head = new_node;}

Python3

 # This function is in LinkedList class# Function to insert a new node at the beginningdef push(self, new_data):      # 1 & 2: Allocate the Node &    #        Put in the data    new_node = Node(new_data)              # 3. Make next of new Node as head    new_node.next = self.head              # 4. Move the head to point to new Node     self.head = new_node

C#

 /* Inserts a new Node at front of the list. */public void push(int new_data){    /* 1 & 2: Allocate the Node &               Put in the data*/    Node new_node = new Node(new_data);      /* 3. Make next of new Node as head */    new_node.next = head;      /* 4. Move the head to point to new Node */    head = new_node;}

Javascript



Complexity Analysis:

• Time Complexity: O(1), We have a pointer to the head and we can directly attach a node and change the pointer. So the Time complexity of inserting a node at the head position is O(1) as it does a constant amount of work.
• Auxiliary Space: O(1)

Add a node after a given node: (5 steps process)

Approach: We are given a pointer to a node, and the new node is inserted after the given node.

• Firstly, check if the given previous node is NULL or not.
• Then, allocate a new node and
• Assign the data to the new node
• And then make the next of new node as the next of previous node.
• Finally, move the next of the previous node as a new node.

C++

 // Given a node prev_node, insert a// new node after the given// prev_nodevoid insertAfter(Node* prev_node, int new_data){      // 1. Check if the given prev_node is NULL    if (prev_node == NULL) {        cout << "The given previous node cannot be NULL";        return;    }      // 2. Allocate new node    Node* new_node = new Node();      // 3. Put in the data    new_node->data = new_data;      // 4. Make next of new node as    // next of prev_node    new_node->next = prev_node->next;      // 5. move the next of prev_node    // as new_node    prev_node->next = new_node;}  // This code is contributed by anmolgautam818,// arkajyotibasak

C

 /* Given a node prev_node, insert a new node after the givenprev_node */void insertAfter(struct Node* prev_node, int new_data){    /*1. check if the given prev_node is NULL */    if (prev_node == NULL) {        printf("the given previous node cannot be NULL");        return;    }      /* 2. allocate new node */    struct Node* new_node        = (struct Node*)malloc(sizeof(struct Node));      /* 3. put in the data */    new_node->data = new_data;      /* 4. Make next of new node as next of prev_node */    new_node->next = prev_node->next;      /* 5. move the next of prev_node as new_node */    prev_node->next = new_node;}

Java

 /* This function is in LinkedList class.Inserts a new node after the given prev_node. This method isdefined inside LinkedList class shown above */public void insertAfter(Node prev_node, int new_data){    /* 1. Check if the given Node is null */    if (prev_node == null) {        System.out.println(            "The given previous node cannot be null");        return;    }      /* 2. Allocate the Node &    3. Put in the data*/    Node new_node = new Node(new_data);      /* 4. Make next of new Node as next of prev_node */    new_node.next = prev_node.next;      /* 5. make next of prev_node as new_node */    prev_node.next = new_node;}

Python3

 # This function is in LinkedList class.# Inserts a new node after the given prev_node. This method is# defined inside LinkedList class shown above */    def insertAfter(self, prev_node, new_data):      # 1. check if the given prev_node exists    if prev_node is None:        print("The given previous node must inLinkedList.")        return      # 2. Create new node &    # 3. Put in the data    new_node = Node(new_data)      # 4. Make next of new Node as next of prev_node    new_node.next = prev_node.next      # 5. make next of prev_node as new_node    prev_node.next = new_node

C#

 /* Inserts a new node after the given prev_node. */public void insertAfter(Node prev_node, int new_data){    /* 1. Check if the given Node is null */    if (prev_node == null) {        Console.WriteLine("The given previous node"                          + " cannot be null");        return;    }      /* 2 & 3: Allocate the Node &            Put in the data*/    Node new_node = new Node(new_data);      /* 4. Make next of new Node as                next of prev_node */    new_node.next = prev_node.next;      /* 5. make next of prev_node                    as new_node */    prev_node.next = new_node;}

Javascript



Complexity Analysis:

Time complexity: O(1), since prev_node is already given as argument in a method, no need to iterate over list to find prev_node
Auxiliary Space: O(1) since using constant space to modify pointers

Add a node at the end: (6 steps process)

• The new node is always added after the last node of the given Linked List. For example if the given Linked List is 5->10->15->20->25 and we add an item 30 at the end, then the Linked List becomes 5->10->15->20->25->30.
• Since a Linked List is typically represented by the head of it, we have to traverse the list till the end and then change the next to last node to a new node.

Following are the 6 steps to add a node at the end.

C++

 // Given a reference (pointer to pointer) to the head  // of a list and an int, appends a new node at the end void append(Node** head_ref, int new_data)  {          // 1. allocate node     Node* new_node = new Node();         // Used in step 5     Node *last = *head_ref;         // 2. Put in the data     new_node->data = new_data;          // 3. This new node is going to be      // the last node, so make next of      // it as NULL    new_node->next = NULL;          // 4. If the Linked List is empty,     // then make the new node as head     if (*head_ref == NULL)      {          *head_ref = new_node;          return;      }          // 5. Else traverse till the last node     while (last->next != NULL)    {        last = last->next;      }        // 6. Change the next of last node     last->next = new_node;      return;  }    // This code is contributed by anmolgautam818, arkajyotibasak

C

 /* Given a reference (pointer to pointer) to the head   of a list and an int, appends a new node at the end  */void append(struct Node** head_ref, int new_data){    /* 1. allocate node */    struct Node* new_node = (struct Node*) malloc(sizeof(struct Node));      struct Node *last = *head_ref;  /* used in step 5*/       /* 2. put in the data  */    new_node->data  = new_data;      /* 3. This new node is going to be the last node, so make next           of it as NULL*/    new_node->next = NULL;      /* 4. If the Linked List is empty, then make the new node as head */    if (*head_ref == NULL)    {       *head_ref = new_node;       return;    }             /* 5. Else traverse till the last node */    while (last->next != NULL)        last = last->next;       /* 6. Change the next of last node */    last->next = new_node;    return;    }

Java

 /* Appends a new node at the end.  This method is    defined inside LinkedList class shown above */public void append(int new_data){    /* 1. Allocate the Node &       2. Put in the data       3. Set next as null */    Node new_node = new Node(new_data);      /* 4. If the Linked List is empty, then make the           new node as head */    if (head == null)    {        head = new Node(new_data);        return;    }      /* 4. This new node is going to be the last node, so         make next of it as null */    new_node.next = null;      /* 5. Else traverse till the last node */    Node last = head;     while (last.next != null)        last = last.next;      /* 6. Change the next of last node */    last.next = new_node;    return;}

Python3

 # This function is defined in Linked List class# Appends a new node at the end.  This method is# defined inside LinkedList class shown above    def append(self, new_data):          # 1. Create a new node        # 2. Put in the data        # 3. Set next as None        new_node = Node(new_data)          # 4. If the Linked List is empty, then make the        #    new node as head        if self.head is None:            self.head = new_node            return          # 5. Else traverse till the last node        last = self.head        while (last.next):            last = last.next          # 6. Change the next of last node        last.next = new_node

C#

 /* Appends a new node at the end. This method is defined inside LinkedList class shown above */public void append(int new_data){    /* 1. Allocate the Node &    2. Put in the data    3. Set next as null */    Node new_node = new Node(new_data);      /* 4. If the Linked List is empty,        then make the new node as head */    if (head == null)    {        head = new Node(new_data);        return;    }      /* 4. This new node is going to be     the last node, so make next of it as null */    new_node.next = null;      /* 5. Else traverse till the last node */    Node last = head;     while (last.next != null)        last = last.next;      /* 6. Change the next of last node */    last.next = new_node;    return;}

Javascript



Complexity Analysis:

• Time complexity: O(N), where N is the number of nodes in the linked list. Since there is a loop from head to end, the function does O(n) work.
• This method can also be optimized to work in O(1) by keeping an extra pointer to the tail of the linked list/
• Auxiliary Space: O(1)

Javascript



Output

Created Linked list is:  1 7 8 6 4

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

An alternate method by using a constructor call:

• However, another method uses a constructor call inside the node class to minimize the memory allocation work.
• It also reduces the number of lines of code.

Below is the implementation of the above method:

Javascript



Output

After insertion at head: 2 -> 1 -> NULL

After insertion at tail: 2 -> 1 -> 4 -> 5 -> NULL

After insertion at a given position: 2 -> 1 -> 2 -> 4 -> 5 -> 6 -> NULL

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

You may like to try Practice MCQ Questions on Linked List