# Insert a Node at Front/Beginning of a Linked List

Given a linked list, the task is to insert a new node at the beginning/start/front of the linked list.

Insert a new node at the front of the Linked List

Example:

Input: LinkedList = 2->3->4->5, NewNode = 1

Input: LinkedList = , NewNode = 1

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.

The below steps should be followed to insert a new node at the front of the linked list

• Allocate a new node (say temp).
• Put the required data into temp.
• The ‘next’ pointer of the node should be pointed to the current head.
• Now make the head pointer point to temp.

Below is the implementation of the approach:

## C++

 `// C++ program to show inserting a node` `// at front of given 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` `insertAtFront(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 function prints contents of` `// linked list starting from head` `void` `printList(Node* node)` `{` `    ``while` `(node != NULL) {` `        ``cout << ``" "` `<< node->data;` `        ``node = node->next;` `    ``}` `    ``cout << ``"\n"``;` `}`   `// Driver code` `int` `main()` `{` `    ``// Start with the empty list` `    ``Node* head = NULL;`   `    ``// Insert 1 at the beginning.` `    ``insertAtFront(&head, 1);` `    ``insertAtFront(&head, 2);` `    ``insertAtFront(&head, 3);` `    ``insertAtFront(&head, 4);` `    ``insertAtFront(&head, 5);` `    ``insertAtFront(&head, 6);`   `    ``cout << ``"After inserting Nodes at their front: "``;` `  ``// The nodes will be : 6 5 4 3 2 1` `    ``printList(head);`   `    ``return` `0;` `}`

## C

 `// C program to show inserting a node` `// at front of given 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` `insertAtFront(``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;` `}`   `// 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;` `    ``}` `    ``printf``(``"\n"``);` `}`   `// Driver code` `int` `main()` `{` `    ``// Start with the empty list` `    ``struct` `Node* head = NULL;`   `    ``insertAtFront(&head, 1);` `    ``insertAtFront(&head, 2);` `    ``insertAtFront(&head, 3);` `    ``insertAtFront(&head, 4);` `    ``insertAtFront(&head, 5);` `    ``insertAtFront(&head, 6);`   `    ``printf``(``"After inserting nodes at their front: "``);` `    ``printList(head);`   `    ``return` `0;` `}`

## Java

 `// Java program to show inserting a node` `// at front of given Linked List` `import` `java.io.*;`   `// A linked list node` `class` `Node {` `    ``int` `data;` `    ``Node next;` `}`   `// Class to insert element in LL` `class` `LinkedList {` `    ``Node head; ``// head of list`   `    ``// 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` `insertAtFront(``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;`   `        ``// 4. move the head to point` `        ``// to the new node` `        ``head = new_node;` `    ``}`   `    ``// This function prints contents of` `    ``// linked list starting from head` `    ``void` `printList()` `    ``{` `        ``Node node = head;` `        ``while` `(node != ``null``) {` `            ``System.out.print(node.data + ``" "``);` `            ``node = node.next;` `        ``}` `        ``System.out.println();` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``// Start with the empty list` `        ``LinkedList list = ``new` `LinkedList();`   `        ``list.insertAtFront(``6``);` `        ``list.insertAtFront(``5``);` `        ``list.insertAtFront(``4``);` `        ``list.insertAtFront(``3``);` `        ``list.insertAtFront(``2``);` `        ``list.insertAtFront(``1``);`   `        ``System.out.print(` `            ``"After inserting nodes at their front: "``);` `        ``list.printList();` `    ``}` `}`

## Python3

 `# Python3 program to show inserting a node` `# at front of given Linked List`   `# A linked list node`     `class` `Node:` `    ``def` `__init__(``self``):` `        ``self``.data ``=` `None` `        ``self``.``next` `=` `None`   `# 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.`     `def` `insertAtFront(head_ref, new_data):`   `    ``# 1. allocate node` `    ``new_node ``=` `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`   `    ``return` `head_ref`     `# This function prints contents of` `# linked list starting from head`     `def` `printList(node):` `    ``while` `(node !``=` `None``):` `        ``print``(node.data, end``=``" "``)` `        ``node ``=` `node.``next` `    ``print``(``"\n"``)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``# Start with the empty list` `    ``head ``=` `None`   `    ``head ``=` `insertAtFront(head, ``6``)` `    ``head ``=` `insertAtFront(head, ``5``)` `    ``head ``=` `insertAtFront(head, ``4``)` `    ``head ``=` `insertAtFront(head, ``3``)` `    ``head ``=` `insertAtFront(head, ``2``)` `    ``head ``=` `insertAtFront(head, ``1``)`   `    ``print``(``"After inserting nodes at thier front: "``, end``=``"")` `    ``printList(head)`

## C#

 `// C# program to show inserting a node` `// at front of given 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` `insertAtFront(``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;` `    ``}`   `    ``/* 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;` `        ``}` `        ``Console.WriteLine();` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``/* Start with the empty list */` `        ``GFG llist = ``new` `GFG();`   `        ``llist.insertAtFront(6);` `        ``llist.insertAtFront(5);` `        ``llist.insertAtFront(4);` `        ``llist.insertAtFront(3);` `        ``llist.insertAtFront(2);` `        ``llist.insertAtFront(1);`   `        ``Console.Write(``"After inserting nodes at their front: "``);` `        ``llist.printList();` `    ``}` `}`

## Javascript

 `// A linked list node` `class Node {` `    ``constructor(data) {` `        ``this``.data = data;` `        ``this``.next = ``null``;` `    ``}` `}`   `// 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.` `function` `insertAtFront(head_ref, new_data) {` `    ``// 1. Create a new node` `    ``const new_node = ``new` `Node(new_data);`   `    ``// 2. Make the new node point to the current head` `    ``new_node.next = head_ref[0];`   `    ``// 3. Update the head to the new node` `    ``head_ref[0] = new_node;` `}`   `// This function prints contents of` `// linked list starting from head` `function` `printList(node) {` `    ``let current = node;` `    ``while` `(current !== ``null``) {` `        ``console.log(``" "` `+ current.data);` `        ``current = current.next;` `    ``}` `    ``console.log(``"\n"``);` `}`   `// Driver code` `function` `main() {` `    ``// Start with an empty list` `    ``const head = [``null``]; ``// Use an array to simulate a pointer to pointer`   `    ``// Insert elements at the beginning` `    ``insertAtFront(head, 1);` `    ``insertAtFront(head, 2);` `    ``insertAtFront(head, 3);` `    ``insertAtFront(head, 4);` `    ``insertAtFront(head, 5);` `    ``insertAtFront(head, 6);`   `    ``console.log(``"After inserting Nodes at their front:"``);` `    ``// The nodes will be: 6 5 4 3 2 1` `    ``printList(head[0]);` `}`   `main();`

Output

```Created Linked list is:  2 3 4 5 6
After inserting 1 at front:  1 2 3 4 5 6

```

Explanation: In the above code we have inserted nodes before them and each node is inserted before the already inserted nodes.

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next