Remove Singly Linked List at nth position

Question

# include <iostream>
using namespace std;
class Node
{
public:
    int d;Node*temp1;
    Node*next;Node*temp2;
};
void insert(Node*&head,int x) 
{
    Node*node = new Node(); // allocate memory 2 node let node be an abstract data
    node->d = x; // define data in the new node as new data (saving data define in there)
    node->next = head; // Let next of the new node as head
    head = node; // let pointer name head point new node
}
void print(Node*node) 
{ 
    while (node != NULL) 
    { 
        cout<<' '<<node->d; 
        node = node->next; 
    } 
}
void Delete(Node*&head,int n) // Delete node at position
{
    int i;Node*node=head;// temp1 points 2(n-1)th
    if(n==1)
    {
        head = node->next; // head now points 2 second node.
        return;
    }
    for(i=0;i<n-2;i++)
    {
        head = node->next;
    } // temp1 points 2 (n-1)th Node
    Node*nnode= node->next; // nth node temp1=node temp2=nnode
    node-> next = nnode->next; //(n+1)th Node
    
}
int main()
{
    Node*head = NULL; // Start with empty List
    int a,n,i,x;
    cin>>n;
    for(i=0;i<n;i++)
    {
        cin>>x;
        insert(*&head,x);  
    }
    cout<<"Enter a position:";
    cin>>a;
    Delete(head,a);print(head);
}

The Output is:

3 // how many number that singly linked list can received
1 2 3 // define many numbers
Enter a position : 1
2 1 // false output it should be 2 3

The output should be:

3
1 2 3
Enter a position : 1
Linked List is 1->2->3
position 1 is remove // at any position we want 2 remove it will show that position we remove
2->3  
Enter a position : 4
No data at 4th position
Linked List is 2->3

Answer 1

For starters the declaration of the node of a singly linked list has redundant data members temp1 and temp2 that do not make sense.

The declarations can look like

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

In this case the function insert (that you could call like

insert(head,x); 

instead of

insert(*&head,x); 

as you are doing) will look like

void insert( Node * &head, int x )
{
    head = new Node { x, head };
}

In C++ (and in C) indices start from 0. So the function delete also shall accept indices starting from 0. The type of the corresponding parameter shall be an unsigned integer type for example size_t. Otherwise the user can pass a negative number as an index.

The function produces memory leaks because it in fact does not free allocated nodes. It can invoke undefined behavior when the pointer to the head node is equal to NULL. And in general the function does not make sense.

It can be defined the following way

bool Delete( Node * &head, size_t n )
{
    Node **current = &head;

    while ( *current && n-- )
    {
        current = &( *current )->next;
    }

    bool success = *current != nullptr;

    if ( success )
    {
        Node *tmp = *current;
        *current = ( *current )->next;
        delete tmp;
    }

    return success;
}

Here is a demonstrative program.

#include <iostream>

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

void insert( Node * &head, int x )
{
    head = new Node { x, head };
}

bool Delete( Node * &head, size_t n )
{
    Node **current = &head;

    while ( *current && n-- )
    {
        current = &( *current )->next;
    }

    bool success = *current != nullptr;

    if ( success )
    {
        Node *tmp = *current;
        *current = ( *current )->next;
        delete tmp;
    }

    return success;
}

std::ostream & print( Node * &head, std::ostream &os = std::cout )
{
    for ( Node *current = head; current != nullptr; current = current->next )
    {
        os << current->data << " -> ";
    }
    
    return os << "null";
}

int main() 
{
    Node *head = nullptr;
    
    for ( int i = 3; i != 0; i-- ) insert( head, i );
    
    print( head ) << '\n';
    
    size_t pos = 0;

    if ( Delete( head, pos ) )
    {
        print( head ) << '\n';
    }
    else
    {
        std::cout << "No data at the position " << pos << '\n';
    }
    
    pos = 4;
    
    if ( Delete( head, pos ) )
    {
        print( head ) << '\n';
    }
    else
    {
        std::cout << "No data at the position " << pos << '\n';
    }
    
    pos = 1;
    
    if ( Delete( head, pos ) )
    {
        print( head ) << '\n';
    }
    else
    {
        std::cout << "No data at the position " << pos << '\n';
    }
    
    pos = 0;
    
    if ( Delete( head, pos ) )
    {
        print( head ) << '\n';
    }
    else
    {
        std::cout << "No data at the position " << pos << '\n';
    }
    
    return 0;
}

Its output is

1 -> 2 -> 3 -> null
2 -> 3 -> null
No data at the position 4
2 -> null
null

Answer 2

In the Delete function you have the loop

for(i=0;i<n-2;i++)
{
    head = node->next;
}

Because you pass head by reference, you actively destroy the list with this loop. Furthermore since you have node = head earlier, the assignment is effectively head = head->next in the first iteration.

You need to use the variable node instead of head:

for(i=0;i<n-2;i++)
{
    node = node->next;
}

---

You also need to protect against going beyond the end of the list:

for(i = 0; (i < n - 2) && (node->next != nullptr) ;i++)