Skip to content
Related Articles

Related Articles

C++ Program For Deleting A Given Node In Linked List Under Given Constraints

View Discussion
Improve Article
Save Article
Like Article
  • Last Updated : 22 Jun, 2022

Given a Singly Linked List, write a function to delete a given node. Your function must follow the following constraints: 

  1. It must accept a pointer to the start node as the first parameter and node to be deleted as the second parameter i.e., a pointer to the head node is not global.
  2. It should not return a pointer to the head node.
  3. It should not accept pointer to pointer to the head node.

You may assume that the Linked List never becomes empty.
Let the function name be deleteNode(). In a straightforward implementation, the function needs to modify the head pointer when the node to be deleted is the first node. As discussed in previous post, when a function modifies the head pointer, the function must use one of the given approaches, we can’t use any of those approaches here. 
Solution: 
We explicitly handle the case when the node to be deleted is the first node, we copy the data of the next node to head and delete the next node. The cases when a deleted node is not the head node can be handled normally by finding the previous node and changing the next of the previous node. The following are the implementation.

C++




// C++ program to delete a given node
// in linked list under given constraints
#include <bits/stdc++.h>
using namespace std;
 
// Structure of a linked list
// node
class Node
{
    public:
    int data;
    Node *next;
};
 
void deleteNode(Node *head,
                Node *n)
{
    // When node to be deleted is
    // head node
    if(head == n)
    {
        if(head->next == NULL)
        {
            cout << "There is only one node." <<
                    " The list can't be made empty ";
            return;
        }
 
        // Copy the data of next node
        // to head
        head->data = head->next->data;
 
        // Store address of next node
        n = head->next;
 
        // Remove the link of next node
        head->next = head->next->next;
 
        // Free memory
        free(n);
 
        return;
    }
 
    // When not first node, follow
    // the normal deletion process
 
    // Find the previous node
    Node *prev = head;
    while(prev->next != NULL &&
          prev->next != n)
        prev = prev->next;
 
    // Check if node really exists in
    // Linked List
    if(prev->next == NULL)
    {
        cout <<
        "Given node is not present in Linked List";
        return;
    }
 
    // Remove node from Linked List
    prev->next = prev->next->next;
 
    // Free memory
    free(n);
 
    return;
}
 
/* Utility function to insert a
   node at the beginning */
void push(Node **head_ref,
          int new_data)
{
    Node *new_node = new Node();
    new_node->data = new_data;
    new_node->next = *head_ref;
    *head_ref = new_node;
}
 
/* Utility function to print a
   linked list */
void printList(Node *head)
{
    while(head != NULL)
    {
        cout << head->data << " ";
        head = head->next;
    }
    cout << endl;
}
 
// Driver code
int main()
{
    Node *head = NULL;
 
    /* Create following linked list
       12->15->10->11->5->6->2->3 */
    push(&head,3);
    push(&head,2);
    push(&head,6);
    push(&head,5);
    push(&head,11);
    push(&head,10);
    push(&head,15);
    push(&head,12);
 
    cout << "Given Linked List: ";
    printList(head);
 
    /* Let us delete the node with
       value 10 */
    cout << "Deleting node " <<
             head->next->next->data << " ";
    deleteNode(head, head->next->next);
 
    cout << "Modified Linked List: ";
    printList(head);
 
    // Let us delete the first node
    cout << "Deleting first node ";
    deleteNode(head, head);
 
    cout << "Modified Linked List: ";
    printList(head);
    return 0;
}
// This code is contributed by rathbhupendra


Output:

Given Linked List: 12 15 10 11 5 6 2 3

Deleting node 10:
Modified Linked List: 12 15 11 5 6 2 3

Deleting first node
Modified Linked List: 15 11 5 6 2 3

Time Complexity: O(n), where n represents the size of the given array.
Auxiliary Space: O(1), no extra space is required, so it is a constant.

Please refer complete article on Delete a given node in Linked List under given constraints for more details!


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!