## Related Articles

• Write an Interview Experience

• Difficulty Level : Easy
• Last Updated : 31 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``class` `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 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`` ` `# Linked List class``class` `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 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)

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

 ``

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)

## C++

 `// A complete working C++ program to  ``// demonstrate all insertion methods ``// on Linked List ``#include ``using` `namespace` `std;`` ` `// A linked list node ``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.``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; ``} `` ` `// 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``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 function prints contents of``// linked list starting from head ``void` `printList(Node *node) ``{ ``    ``while` `(node != NULL) ``    ``{ ``        ``cout<<``" "``<data; ``        ``node = node->next; ``    ``} ``} `` ` `// Driver code``int` `main() ``{ ``   ` `    ``// Start with the empty list``    ``Node* head = NULL; ``     ` `    ``// Insert 6. So linked list becomes 6->NULL ``    ``append(&head, 6); ``     ` `    ``// Insert 7 at the beginning. ``    ``// So linked list becomes 7->6->NULL ``    ``push(&head, 7); ``     ` `    ``// Insert 1 at the beginning. ``    ``// So linked list becomes 1->7->6->NULL ``    ``push(&head, 1); ``     ` `    ``// Insert 4 at the end. So ``    ``// linked list becomes 1->7->6->4->NULL ``    ``append(&head, 4); ``     ` `    ``// Insert 8, after 7. So linked ``    ``// list becomes 1->7->8->6->4->NULL ``    ``insertAfter(head->next, 8); ``     ` `    ``cout<<``"Created Linked list is: "``; ``    ``printList(head); ``     ` `    ``return` `0; ``} ``// This code is contributed by rathbhupendra, arkajyotibasak`

## C

 `// A complete working C program to demonstrate all insertion methods``// on Linked List``#include ``#include `` ` `// A linked list node``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 */``    ``new_node->next = (*head_ref);`` ` `    ``/* 4. move the head to point to the new node */``    ``(*head_ref)    = 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 */``    ``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 function prints contents of linked list starting from head``void` `printList(``struct` `Node *node)``{``  ``while` `(node != NULL)``  ``{``     ``printf``(``" %d "``, node->data);``     ``node = node->next;``  ``}``}`` ` `/* Driver program to test above functions*/``int` `main()``{``  ``/* Start with the empty list */``  ``struct` `Node* head = NULL;`` ` `  ``// Insert 6.  So linked list becomes 6->NULL``  ``append(&head, 6);`` ` `  ``// Insert 7 at the beginning. So linked list becomes 7->6->NULL``  ``push(&head, 7);`` ` `  ``// Insert 1 at the beginning. So linked list becomes 1->7->6->NULL``  ``push(&head, 1);`` ` `  ``// Insert 4 at the end. So linked list becomes 1->7->6->4->NULL``  ``append(&head, 4);`` ` `  ``// Insert 8, after 7. So linked list becomes 1->7->8->6->4->NULL``  ``insertAfter(head->next, 8);`` ` `  ``printf``(``"\n Created Linked list is: "``);``  ``printList(head);`` ` `  ``return` `0;``}`

## Java

 `// A complete working Java program to demonstrate all insertion methods``// on linked list``import` `java.io.*;``public` `class` `LinkedList``{``    ``Node head;  ``// head of list`` ` `    ``/* Linked list Node*/``    ``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 */``        ``new_node.next = head;`` ` `        ``/* 4. Move the head to point to new Node */``        ``head = 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``              ``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``;``    ``}`` ` `    ``/* This function prints contents of linked list starting from``        ``the given node */``    ``public` `void` `printList()``    ``{``        ``Node tnode = head;``        ``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)``    ``{``        ``/* Start with the empty list */``        ``LinkedList llist = ``new` `LinkedList();`` ` `        ``// 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.insertAfter(llist.head.next, ``8``);`` ` `        ``System.out.println(``"\nCreated Linked list is: "``);``        ``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``class` `LinkedList:`` ` `    ``# Function to initialize head``    ``def` `__init__(``self``):``        ``self``.head ``=` `None`` ` ` ` `    ``# 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`` ` ` ` `    ``# 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``        ``#    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`` ` ` ` `    ``# Utility function to print the linked list``    ``def` `printList(``self``):``        ``temp ``=` `self``.head``        ``while` `(temp):``            ``print``(temp.data,end``=``" "``)``            ``temp ``=` `temp.``next`` ` ` ` ` ` `# Code execution starts here``if` `__name__``=``=``'__main__'``:`` ` `    ``# Start with the empty list``    ``llist ``=` `LinkedList()`` ` `    ``# 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.insertAfter(llist.head.``next``, ``8``)`` ` `    ``print``(``'Created linked list is: '``)``    ``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` `Node head; ``// head of list`` ` `    ``/* Linked list Node*/``    ``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 */``        ``new_node.next = head;`` ` `        ``/* 4. Move the head to point to new Node */``        ``head = 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 */``        ``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``;``    ``}`` ` `    ``/* This function prints contents of linked list ``    ``starting from the given node */``    ``public` `void` `printList()``    ``{``        ``Node tnode = head;``        ``while` `(tnode != ``null``)``        ``{``            ``Console.Write(tnode.data + ``" "``);``            ``tnode = tnode.next;``        ``}``    ``}`` ` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``/* Start with the empty list */``        ``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.insertAfter(llist.head.next, 8);`` ` `        ``Console.Write(``"Created Linked list is: "``);``        ``llist.printList();``    ``}``}`` ` `// This code is contributed by Rajput-Ji`

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

## C++

 `// Alternate method to declare the class``// in order to minimize the``// memory allocation work`` ` `#include ``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``// at head position``void` `insertathead(node*& head, ``int` `val)``{``    ``node* n = ``new` `node(val);``    ``n->next = head;``    ``head = n;``}`` ` `// Function to insert a element``// at a specified position``void` `insertafter(node* head, ``int` `key, ``int` `val)``{``    ``node* n = ``new` `node(val);``    ``if` `(key == head->data) {``        ``n->next = head->next;``        ``head->next = n;``        ``return``;``    ``}`` ` `    ``node* temp = head;``    ``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``void` `insertattail(node*& head, ``int` `val)``{``    ``node* n = ``new` `node(val);``    ``if` `(head == NULL) {``        ``head = n;``        ``return``;``    ``}`` ` `    ``node* temp = head;``    ``while` `(temp->next != NULL) {``        ``temp = temp->next;``    ``}``    ``temp->next = n;``}`` ` `// Function to print the``// singly linked list``void` `print(node*& head)``{``    ``node* temp = head;`` ` `    ``while` `(temp != NULL) {``        ``cout << temp->data << ``" -> "``;``        ``temp = temp->next;``    ``}``    ``cout << ``"NULL"` `<< endl;``}`` ` `// Main function``int` `main()``{`` ` `    ``// Declaring an empty linked list``    ``node* head = NULL;`` ` `    ``insertathead(head, 1);``    ``insertathead(head, 2);``    ``cout << ``"After insertion at head: "``;``    ``print(head);``    ``cout << endl;`` ` `    ``insertattail(head, 4);``    ``insertattail(head, 5);``    ``cout << ``"After insertion at tail: "``;``    ``print(head);``    ``cout << endl;`` ` `    ``insertafter(head, 1, 2);``    ``insertafter(head, 5, 6);``    ``cout << ``"After insertion at a given position: "``;``    ``print(head);``    ``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``    ``static` `node head = ``null``;`` ` `    ``// Function to insert an element at head position``    ``static` `void` `insertathead(``int` `val)``    ``{``        ``node n = ``new` `node(val);``        ``n.next = head;``        ``head = n;``    ``}`` ` `    ``// Function to insert a element at a specified position``    ``static` `void` `insertafter(``int` `key, ``int` `val)``    ``{``        ``node n = ``new` `node(val);``        ``if` `(key == head.data) {``            ``n.next = head.next;``            ``head.next = n;``            ``return``;``        ``}``        ``node temp = head;``        ``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);``        ``if` `(head == ``null``) {``            ``head = n;``            ``return``;``        ``}``        ``node temp = head;``        ``while` `(temp.next != ``null``) {``            ``temp = temp.next;``        ``}``        ``temp.next = n;``    ``}`` ` `    ``// Function to print the singly linked list``    ``static` `void` `print()``    ``{``        ``node temp = head;``        ``while` `(temp != ``null``) {``            ``System.out.print(temp.data + ``" -> "``);``            ``temp = temp.next;``        ``}``        ``System.out.println(``"NULL"``);``    ``}`` ` `    ``public` `static` `void` `main(String[] args)``    ``{`` ` `        ``insertathead(``1``);``        ``insertathead(``2``);``        ``System.out.print(``"After insertion at head: "``);``        ``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``class` `LinkedList:`` ` `    ``# Function to initialize head``    ``def` `__init__(``self``):``        ``self``.head ``=` `None`` ` `    ``'''This function is in LinkedList class.``    ``It inserts a new node at the beginning'''``    ``def` `insertAtHead(``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`` ` `    ``'''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``        ``if` `self``.head ``is` `None``:``            ``return`` ` `        ``# 2. Create new node & Put in the data``        ``new_node ``=` `Node(new_data)`` ` `        ``# 3. If prev_data is at the first position``        ``if` `(prev_data ``=``=` `self``.head.data):``            ``new_node.``next` `=` `self``.head.``next``            ``self``.head.``next` `=` `new_node``            ``return`` ` `        ``# 4. check if the given prev_data exists``        ``head ``=` `self``.head``        ``while` `(head.data !``=` `prev_data):``            ``head ``=` `head.``next``            ``if` `head ``=``=` `None``:``                ``return``        ``new_node.``next` `=` `head.``next``        ``head.``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` `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``        ``#    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`` ` `    ``# Utility function to print the linked list``    ``def` `printList(``self``):``        ``temp ``=` `self``.head``        ``while` `(temp):``            ``print``(temp.data, end``=``" -> "``)``            ``temp ``=` `temp.``next``        ``print``(``"NULL"``)`` ` ` ` `# Code execution starts here``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``# Start with the empty list``    ``llist ``=` `LinkedList()`` ` `    ``llist.insertAtHead(``1``)``    ``llist.insertAtHead(``2``)``    ``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``  ``public` `static` `void` `insertathead(``int` `val)``  ``{``    ``node n = ``new` `node(val);``    ``n.next = head;``    ``head = n;``  ``}`` ` `  ``// Function to insert a element at a specified position``  ``public` `static` `void` `insertafter(``int` `key, ``int` `val)``  ``{``    ``node n = ``new` `node(val);``    ``if` `(key == head.data) {``      ``n.next = head.next;``      ``head.next = n;``      ``return``;``    ``}``    ``node temp = head;``    ``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);``    ``if` `(head == ``null``) {``      ``head = n;``      ``return``;``    ``}``    ``node temp = head;``    ``while` `(temp.next != ``null``) {``      ``temp = temp.next;``    ``}``    ``temp.next = n;``  ``}`` ` `  ``// Function to print the singly linked list``  ``public` `static` `void` `print()``  ``{``    ``node temp = head;``    ``while` `(temp != ``null``) {``      ``Console.Write(temp.data + ``" -> "``);``      ``temp = temp.next;``    ``}``    ``Console.WriteLine(``"NULL"``);``  ``}`` ` `  ``static` `public` `void` `Main()``  ``{`` ` `    ``insertathead(1);``    ``insertathead(2);``    ``Console.Write(``"After insertion at head: "``);``    ``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

 ``

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