Last Updated : 22 Feb, 2024

Given a Linked List, the task is to insert a new node in this given Linked List at the following positions:Â

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

## How to Insert a Node at the Front/Beginning of Linked List

Approach:Â

To insert a node at the start/beginning/front of a Linked List, we need to:

• Make the first node of Linked List linked to the new node
• Remove the head from the original first node of Linked List
• Make the new node as the Head of the Linked List.

Below is the implementation of the approach:

## 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;` `}`

## 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 beginning` `def` `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)

Refer this post for detailed implementation of the above approach.

## How to Insert a Node after a Given Node in Linked List

Approach:Â

To insert a node after a given node in a Linked List, we need to:

• Check if the given node exists or not.Â
• If it do not exists,Â
• terminate the process.
• If the given node exists,
• Make the element to be inserted as a new node
• Change the next pointer of given node to the new node
• Now shift the original next pointer of given node to the next pointer of new node

Below is the implementation of the approach:

## C++

 `// Given a node prev_node, insert a` `// new node after the given` `// prev_node` `void` `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;` `}`

## C

 `/* Given a node prev_node, insert a new node after the given` `prev_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 is` `defined 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

Refer this post for detailed implementation of the above approach.

## How to Insert a Node at the End of Linked List

Approach:Â

To insert a node at the end of a Linked List, we need to:

• Go to the last node of the Linked List
• Change the next pointer of last node from NULL to the new node
• Make the next pointer of new node as NULL to show the end of Linked List

Below is the implementation of the approach:

## 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``;` `}`

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

Refer this post for detailed implementation of the above approach.

Previous
Next