C++ Program For Inserting Node In The Middle Of The Linked List
Last Updated :
10 Jul, 2022
Given a linked list containing n nodes. The problem is to insert a new node with data x at the middle of the list. If n is even, then insert the new node after the (n/2)th node, else insert the new node after the (n+1)/2th node.
Examples:
Input : list: 1->2->4->5
x = 3
Output : 1->2->3->4->5
Input : list: 5->10->4->32->16
x = 41
Output : 5->10->4->41->32->16
Method 1(Using length of the linked list):
Find the number of nodes or length of the linked using one traversal. Let it be len. Calculate c = (len/2), if len is even, else c = (len+1)/2, if len is odd. Traverse again the first c nodes and insert the new node after the cth node.
C++
// C++ implementation to insert node at the middle
// of the linked list
#include <bits/stdc++.h>
using namespace std;
// structure of a node
struct Node {
int data;
Node* next;
};
// function to create and return a node
Node* getNode(int data)
{
// allocating space
Node* newNode = (Node*)malloc(sizeof(Node));
// inserting the required data
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// function to insert node at the middle
// of the linked list
void insertAtMid(Node** head_ref, int x)
{
// if list is empty
if (*head_ref == NULL)
*head_ref = getNode(x);
else {
// get a new node
Node* newNode = getNode(x);
Node* ptr = *head_ref;
int len = 0;
// calculate length of the linked list
//, i.e, the number of nodes
while (ptr != NULL) {
len++;
ptr = ptr->next;
}
// 'count' the number of nodes after which
// the new node is to be inserted
int count = ((len % 2) == 0) ? (len / 2) :
(len + 1) / 2;
ptr = *head_ref;
// 'ptr' points to the node after which
// the new node is to be inserted
while (count-- > 1)
ptr = ptr->next;
// insert the 'newNode' and adjust the
// required links
newNode->next = ptr->next;
ptr->next = newNode;
}
}
// function to display the linked list
void display(Node* head)
{
while (head != NULL) {
cout << head->data << " ";
head = head->next;
}
}
// Driver program to test above
int main()
{
// Creating the list 1->2->4->5
Node* head = NULL;
head = getNode(1);
head->next = getNode(2);
head->next->next = getNode(4);
head->next->next->next = getNode(5);
cout << "Linked list before insertion: ";
display(head);
int x = 3;
insertAtMid(&head, x);
cout << "
Linked list after insertion: ";
display(head);
return 0;
}
Output:
Linked list before insertion: 1 2 4 5
Linked list after insertion: 1 2 3 4 5
Time Complexity: O(n)
Space complexity: O(1) since using constant space
Method 2(Using two pointers):
Based on the tortoise and hare algorithm which uses two pointers, one known as slow and the other known as fast. This algorithm helps in finding the middle node of the linked list. It is explained in the front and black split procedure of this post. Now, you can insert the new node after the middle node obtained from the above process. This approach requires only a single traversal of the list.
C++
// C++ implementation to insert node at the middle
// of the linked list
#include <bits/stdc++.h>
using namespace std;
// structure of a node
struct Node {
int data;
Node* next;
};
// function to create and return a node
Node* getNode(int data)
{
// allocating space
Node* newNode = (Node*)malloc(sizeof(Node));
// inserting the required data
newNode->data = data;
newNode->next = NULL;
return newNode;
}
// function to insert node at the middle
// of the linked list
void insertAtMid(Node** head_ref, int x)
{
// if list is empty
if (*head_ref == NULL)
*head_ref = getNode(x);
else {
// get a new node
Node* newNode = getNode(x);
// assign values to the slow and fast
// pointers
Node* slow = *head_ref;
Node* fast = (*head_ref)->next;
while (fast && fast->next) {
// move slow pointer to next node
slow = slow->next;
// move fast pointer two nodes at a time
fast = fast->next->next;
}
// insert the 'newNode' and adjust the
// required links
newNode->next = slow->next;
slow->next = newNode;
}
}
// function to display the linked list
void display(Node* head)
{
while (head != NULL) {
cout << head->data << " ";
head = head->next;
}
}
// Driver program to test above
int main()
{
// Creating the list 1->2->4->5
Node* head = NULL;
head = getNode(1);
head->next = getNode(2);
head->next->next = getNode(4);
head->next->next->next = getNode(5);
cout << "Linked list before insertion: ";
display(head);
int x = 3;
insertAtMid(&head, x);
cout << "
Linked list after insertion: ";
display(head);
return 0;
}
Output:
Linked list before insertion: 1 2 4 5
Linked list after insertion: 1 2 3 4 5
Time Complexity: O(n)
Space complexity: O(n) where n is size of linked list
Please refer complete article on Insert node into the middle of the linked list for more details!
Similar Reads
C++ Program For Inserting A Node In A Linked List Inserting a node into a linked list can be done in several ways, depending on where we want to insert the new node. Here, we'll cover four common scenarios: inserting at the front of the list, after a given node, at a specific position, and at the end of the listTable of ContentInsert a Node at the
9 min read
C++ Program For Making Middle Node Head In A Linked List Given a singly linked list, find middle of the linked list and set middle node of the linked list at beginning of the linked list. Examples: Input: 1 2 3 4 5 Output: 3 1 2 4 5 Input: 1 2 3 4 5 6 Output: 4 1 2 3 5 6 The idea is to first find middle of a linked list using two pointers, first one moves
3 min read
C++ Program For Insertion Sort In A Singly Linked List We have discussed Insertion Sort for arrays. In this article we are going to discuss Insertion Sort for linked list. Below is a simple insertion sort algorithm for a linked list. 1) Create an empty sorted (or result) list. 2) Traverse the given list, do following for every node. ......a) Insert curr
5 min read
C++ Program To Delete Middle Of Linked List Given a singly linked list, delete the middle of the linked list. For example, if the given linked list is 1->2->3->4->5 then the linked list should be modified to 1->2->4->5 If there are even nodes, then there would be two middle nodes, we need to delete the second middle element. For example, if g
4 min read
C++ Program For Inserting A Node After The N-th Node From The End Insert a node x after the nth node from the end in the given singly linked list. It is guaranteed that the list contains the nth node from the end. Also 1 <= n. Examples: Input : list: 1->3->4->5 n = 4, x = 2 Output : 1->2->3->4->5 4th node from the end is 1 and insertion has
5 min read