 Open in App
Not now

• Difficulty Level : Easy
• Last Updated : 12 Jan, 2023

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 node
struct Node
{
int data;
struct Node *next;
};
```

## Java

```// Linked List Class
{

/* Node Class */
class Node
{
int data;
Node next;

// Constructor to create a new node
Node(int d) {data = d; next = null; }
}
}```

## Python3

```# Node class
class Node:

# Function to initialize the node object
def __init__(self, data):
self.data = data  # Assign data
self.next = None  # Initialize next as null

# Function to initialize the Linked List object
def __init__(self):
```

## C#

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

```

## Javascript

```<script>

/* Node Class */
class Node {

// Constructor to create a new node
constructor(d) {
this.data = d;
this.next = null;
}
}
// This code is contributed by todaysgaurav
</script>
``` 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.
{

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

// 4. Move the head to point to
// the 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 */

/* 4. move the head to point to the 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 */

/* 4. Move the head to point to 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

# 4. Move the head to point to 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 */

/* 4. Move the head to point to new Node */
}

```

## Javascript

```<script>

/* This function is in LinkedList class. Inserts a
new Node at front of the list. This method is
defined inside LinkedList class shown above */

function push(new_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
var new_node = new Node(new_data);

/* 3. Make next of new Node as head */

/* 4. Move the head to point to new Node */
}

// This code contributed by Rajput-Ji

</script>
```

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_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;
}

// This code is contributed by anmolgautam818,
// arkajyotibasak```

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

```<script>

/* This function is in LinkedList class.
Inserts a new node after the given prev_node. This method is
defined inside LinkedList class shown above */
function insertAfter(prev_node , new_data)
{

/* 1. Check if the given Node is null */
if (prev_node == null)
{
document.write("The given previous node cannot be null");
return;
}

/* 2. Allocate the Node &
3. Put in the data*/
var 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;
}

// This code is contributed by aashish1995

</script>```

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
{

// 1. allocate node
Node* new_node = new Node();

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

# 5. Else traverse till the last node
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 */
{
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 */
while (last.next != null)
last = last.next;

/* 6. Change the next of last node */
last.next = new_node;
return;
}

```

## Javascript

```<script>

/* Appends a new node at the end.  This method is
defined inside LinkedList class shown above */
function append(new_data)
{
/* 1. Allocate the Node &
2. Put in the data
3. Set next as null */
var new_node = new Node(new_data);

/* 4. If the Linked List is empty, then make the
{
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 */
while (last.next != null)
last = last.next;

/* 6. Change the next of last node */
last.next = new_node;
return;
}

// This code contributed by aashish1995
</script>

```

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)

## C++

```// A complete working C++ program to
// demonstrate all insertion methods
#include <bits/stdc++.h>
using namespace std;

class Node
{
public:
int data;
Node *next;
};

// 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.
{

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

// 4. move the head to point
// to the new node
}

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

// Given a reference (pointer to pointer)
// to the head of a list and an int,
// appends a new node at the end
{

// 1. allocate node
Node* new_node = new Node();

//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 */
{
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 function prints contents of
void printList(Node *node)
{
while (node != NULL)
{
cout<<" "<<node->data;
node = node->next;
}
}

// Driver code
int main()
{

// Insert 6. So linked list becomes 6->NULL

// Insert 7 at the beginning.
// So linked list becomes 7->6->NULL

// Insert 1 at the beginning.
// So linked list becomes 1->7->6->NULL

// Insert 4 at the end. So

// Insert 8, after 7. So linked
// list becomes 1->7->8->6->4->NULL

return 0;
}
// This code is contributed by rathbhupendra, arkajyotibasak```

## C

```// A complete working C program to demonstrate all insertion methods
#include <stdio.h>
#include <stdlib.h>

struct Node
{
int data;
struct Node *next;
};

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

/* 4. move the head to point to the new node */
}

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

/* 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 */
{
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;
}

void printList(struct Node *node)
{
while (node != NULL)
{
printf(" %d ", node->data);
node = node->next;
}
}

/* Driver program to test above functions*/
int main()
{

// Insert 6.  So linked list becomes 6->NULL

// Insert 7 at the beginning. So linked list becomes 7->6->NULL

// Insert 1 at the beginning. So linked list becomes 1->7->6->NULL

// Insert 4 at the end. So linked list becomes 1->7->6->4->NULL

// Insert 8, after 7. So linked list becomes 1->7->8->6->4->NULL

printf("\n Created Linked list is: ");

return 0;
}
```

## Java

```// A complete working Java program to demonstrate all insertion methods
import java.io.*;
{

class Node
{
int data;
Node next;
Node(int d) {data = d; next = null; }
}

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

/* 4. Move the head to point to new Node */
}

/* 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)
{
System.out.println("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;
}

/* 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
{
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 */
while (last.next != null)
last = last.next;

/* 6. Change the next of last node */
last.next = new_node;
return;
}

/* This function prints contents of linked list starting from
the given node */
public void printList()
{
while (tnode != null)
{
System.out.print(tnode.data+" ");
tnode = tnode.next;
}
}

/* Driver program to test above functions. Ideally this function
should be in a separate user class.  It is kept here to keep
code compact */
public static void main(String[] args)
{

// Insert 6.  So linked list becomes 6->NUllist
llist.append(6);

// Insert 7 at the beginning. So linked list becomes
// 7->6->NUllist
llist.push(7);

// Insert 1 at the beginning. So linked list becomes
// 1->7->6->NUllist
llist.push(1);

// Insert 4 at the end. So linked list becomes
// 1->7->6->4->NUllist
llist.append(4);

// Insert 8, after 7. So linked list becomes
// 1->7->8->6->4->NUllist

llist.printList();
}
}
// This code is contributed by Rajat Mishra
```

## Python3

```# A complete working Python program to demonstrate all
# insertion methods of linked list

# Node class
class Node:

# Function to initialise the node object
def __init__(self, data):
self.data = data  # Assign data
self.next = None  # Initialize next as null

# Linked List class contains a Node object

def __init__(self):

# 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

# 4. Move the head to point to new Node

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

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

# 5. Else traverse till the last node
while (last.next):
last = last.next

# 6. Change the next of last node
last.next =  new_node

# Utility function to print the linked list
def printList(self):
while (temp):
print(temp.data,end=" ")
temp = temp.next

# Code execution starts here
if __name__=='__main__':

# Insert 6.  So linked list becomes 6->None
llist.append(6)

# Insert 7 at the beginning. So linked list becomes 7->6->None
llist.push(7);

# Insert 1 at the beginning. So linked list becomes 1->7->6->None
llist.push(1);

# Insert 4 at the end. So linked list becomes 1->7->6->4->None
llist.append(4)

# Insert 8, after 7. So linked list becomes 1 -> 7-> 8-> 6-> 4-> None

llist.printList()

# This code is contributed by Manikantan Narasimhan
```

## C#

```// A complete working C# program to demonstrate
// all insertion methods on linked list
using System;

class GFG
{

public class Node
{
public int data;
public Node next;
public Node(int d) {data = d; next = null;}
}

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

/* 4. Move the head to point to new Node */
}

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

/* 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 */
{
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 */
while (last.next != null)
last = last.next;

/* 6. Change the next of last node */
last.next = new_node;
return;
}

/* This function prints contents of linked list
starting from the given node */
public void printList()
{
while (tnode != null)
{
Console.Write(tnode.data + " ");
tnode = tnode.next;
}
}

// Driver Code
public static void Main(String[] args)
{
GFG llist = new GFG();

// Insert 6. So linked list becomes 6->NUllist
llist.append(6);

// Insert 7 at the beginning.
// So linked list becomes 7->6->NUllist
llist.push(7);

// Insert 1 at the beginning.
// So linked list becomes 1->7->6->NUllist
llist.push(1);

// Insert 4 at the end. So linked list becomes
// 1->7->6->4->NUllist
llist.append(4);

// Insert 8, after 7. So linked list becomes
// 1->7->8->6->4->NUllist

llist.printList();
}
}

// This code is contributed by Rajput-Ji

```

## Javascript

```<script>

// A complete working javascript program
// to demonstrate all insertion methods

class Node {
constructor(val) {
this.data = val;
this.next = null;
}
}

/* Inserts a new Node at front of the list. */
function push(new_data) {
/*
* 1 & 2: Allocate the Node & Put in the data
*/
var new_node = new Node(new_data);

/* 3. Make next of new Node as head */

/* 4. Move the head to point to new Node */
}

/* Inserts a new node after the given prev_node. */
function insertAfter(prev_node , new_data) {
/* 1. Check if the given Node is null */
if (prev_node == null) {
document.write(
"The given previous node cannot be null"
);
return;
}

/*
* 2 & 3: Allocate the Node & Put in the data
*/
var 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;
}

/*
* Appends a new node at the end.
This method is defined inside LinkedList class
* shown above
*/
function append(new_data) {
/*
* 1. Allocate the Node & 2.
Put in the data 3. Set next as null
*/
var new_node = new Node(new_data);

/*
* 4. If the Linked List is empty,
then make the new node as head
*/
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 */
while (last.next != null)
last = last.next;

/* 6. Change the next of last node */
last.next = new_node;
return;
}

/*
* This function prints contents of linked list
starting from the given node
*/
function printList() {
while (tnode != null) {
document.write(tnode.data + " ");
tnode = tnode.next;
}
}

/*
* Driver program to test above functions.
Ideally this function should be in a
* separate user class. It is kept here
to keep code compact
*/

// Insert 6. So linked list becomes 6->NUllist
append(6);

// Insert 7 at the beginning. So linked list becomes
// 7->6->NUllist
push(7);

// Insert 1 at the beginning. So linked list becomes
// 1->7->6->NUllist
push(1);

// Insert 4 at the end. So linked list becomes
// 1->7->6->4->NUllist
append(4);

// Insert 8, after 7. So linked list becomes
// 1->7->8->6->4->NUllist

printList();

// This code contributed by gauravrajput1

</script>
```
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:

## C++

```// Alternate method to declare the class
// in order to minimize the
// memory allocation work

#include <bits/stdc++.h>
using namespace std;

class node {
public:
int data;
node* next;

// A constructor is called here
node(int value)
{

// It automatically assigns the
// value to the data
data = value;

// Next pointer is pointed to NULL
next = NULL;
}
};

// Function to insert an element
{
node* n = new node(val);
}

// Function to insert a element
// at a specified position
void insertafter(node* head, int key, int val)
{
node* n = new node(val);
return;
}

while (temp->data != key) {
temp = temp->next;
if (temp == NULL) {
return;
}
}
n->next = temp->next;
temp->next = n;
}

// Function to insert an
// element at the end
{
node* n = new node(val);
return;
}

while (temp->next != NULL) {
temp = temp->next;
}
temp->next = n;
}

// Function to print the
{

while (temp != NULL) {
cout << temp->data << " -> ";
temp = temp->next;
}
cout << "NULL" << endl;
}

// Main function
int main()
{

// Declaring an empty linked list

cout << "After insertion at head: ";
cout << endl;

cout << "After insertion at tail: ";
cout << endl;

cout << "After insertion at a given position: ";
cout << endl;

return 0;
}
// contributed by divyanshmishra101010```

## Java

```// Alternate method to declare the class
// in order to minimize the
// memory allocation work

import java.io.*;

class node {
int data;
node next;

// constructor call
node(int value)
{

// It automatically assigns the value to the data
data = value;

// next pointer is pointed to null
next = null;
}
}

class GFG {

// Declaring an empty linked list

// Function to insert an element at head position
{
node n = new node(val);
}

// Function to insert a element at a specified position
static void insertafter(int key, int val)
{
node n = new node(val);
return;
}
while (temp.data != key) {
temp = temp.next;
if (temp == null) {
return;
}
}
n.next = temp.next;
temp.next = n;
}

// Function to insert an element at the end
static void insertattail(int val)
{
node n = new node(val);
return;
}
while (temp.next != null) {
temp = temp.next;
}
temp.next = n;
}

// Function to print the singly linked list
static void print()
{
while (temp != null) {
System.out.print(temp.data + " -> ");
temp = temp.next;
}
System.out.println("NULL");
}

public static void main(String[] args)
{

print();
System.out.println();

insertattail(4);
insertattail(5);
System.out.print("After insertion at tail: ");
print();
System.out.println();

insertafter(1, 2);
insertafter(5, 6);
System.out.print(
"After insertion at a given position: ");
print();
System.out.println();
}
}

// This code is contributed by lokeshmvs21.```

## Python3

```'''Alternate method to declare the class
in order to minimize the memory allocation work'''

# Node class
class Node:

# A constructor is called here
def __init__(self, data):
self.data = data  # Automatically assign data
self.next = None  # Initialize next pointer as null

# Linked List class contains a Node object

def __init__(self):

'''This function is in LinkedList class.
It inserts a new node at the beginning'''

# 1 & 2: Allocate the Node &
#        Put in the data
new_node = Node(new_data)

# 3. Make next of new Node as head

# 4. Move the head to point to new Node

'''This function is in LinkedList class. It inserts a
new node after the given prev_data. This method is
defined inside LinkedList class shown above'''
def insertAfter(self, prev_data, new_data):

# 1. check if the Linked List is empty or not
return

# 2. Create new node & Put in the data
new_node = Node(new_data)

# 3. If prev_data is at the first position
return

# 4. check if the given prev_data exists
return

'''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 insertattail(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
return

# 5. Else traverse till the last node
while (last.next):
last = last.next

# 6. Change the next of last node
last.next = new_node

# Utility function to print the linked list
def printList(self):
while (temp):
print(temp.data, end=" -> ")
temp = temp.next
print("NULL")

# Code execution starts here
if __name__ == '__main__':

print("After insertion at head:", end=" ")
llist.printList()
print()

llist.insertattail(4)
llist.insertattail(5)
print("After insertion at tail:", end=" ")
llist.printList()
print()

llist.insertAfter(1, 2)
llist.insertAfter(5, 6)
print("After insertion at a given position:", end=" ")
llist.printList()

# This code is contributed by Susobhan Akhuli
```

## C#

```using System;

// Alternate method to declare the class
// in order to minimize the
// memory allocation work
public class node {
public int data;
public node next;

// constructor call
public node(int value)
{

// It automatically assigns the value to the data
data = value;

// next pointer is pointed to null
next = null;
}
}

public class GFG {

// Declaring an empty linked list
public static node head = null;

// Function to insert an element at head position
{
node n = new node(val);
}

// Function to insert a element at a specified position
public static void insertafter(int key, int val)
{
node n = new node(val);
return;
}
while (temp.data != key) {
temp = temp.next;
if (temp == null) {
return;
}
}
n.next = temp.next;
temp.next = n;
}

// Function to insert an element at the end
public static void insertattail(int val)
{
node n = new node(val);
return;
}
while (temp.next != null) {
temp = temp.next;
}
temp.next = n;
}

// Function to print the singly linked list
public static void print()
{
while (temp != null) {
Console.Write(temp.data + " -> ");
temp = temp.next;
}
Console.WriteLine("NULL");
}

static public void Main()
{

print();
Console.WriteLine();

insertattail(4);
insertattail(5);
Console.Write("After insertion at tail: ");
print();
Console.WriteLine();

insertafter(1, 2);
insertafter(5, 6);
Console.Write(
"After insertion at a given position: ");
print();
Console.WriteLine();
}
}

// This code is contributed by akashish__```

## Javascript

```<script>

// Alternate method to declare the class
// in order to minimize the
// memory allocation work

class Node {
constructor(val) {
this.data = val;
this.next = null;
}
}

// This function inserts a new Node at front of the list.
var new_node = new Node(new_data);
}

// This function inserts a new node after a specefic position
function insertAfter(prev_data , new_data) {
var new_node = new Node(new_data);
}

while (temp.data != prev_data){
temp = temp.next;
if(temp == null)
return;
}
new_node.next = temp.next
temp.next = new_node;
}

// This function appends a new node at the end.
function insertAtTail(new_data) {
var new_node = new Node(new_data);
return;
}

new_node.next = null;

while (last.next != null)
last = last.next;

last.next = new_node;
return;
}

// This function prints contents of linked list.
function printList() {
while (tnode != null) {
document.write(tnode.data + " -> ");
tnode = tnode.next;
}
document.write("NULL");
}

// Driver program
printList();
document.write("<br>");

insertAtTail(4);
insertAtTail(5);
document.write("<br>After insertion at tail: ");
printList();
document.write("<br>");

insertAfter(1, 2);
insertAfter(5, 6);
document.write("<br>After insertion at a given position: ");
printList();
document.write("<br>");

// This code contributed by Susobhan Akhuli

</script>```
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