删除单链表中的节点

Question

Suppose you have a pointer p to a node in a singly linked list that is not on the last node in the list. You have no other pointer to the list except the following links in each node.

Describe an O(1) algorithm that logically removes the value stored in the node pointed to by p (suggestion: use the next node).

The idea to do it is to transfer information from the next node to the current node pointed to by p and the next node is removed from the list. My question is why don't we remove the node pointed by our pointer instead of removing the next node. I am a bit confused.

Answer 1

You have a pointer to the node, but no way to change the previous node's reference to it; therefore you must copy and remove the next node.

Your pointer p only references the current node. Since you can't modify prevous->next to point at the node with value 3, you must copy next node into the current one, both value and next pointer.

Answer 2

My question is why don't we remove the node pointed by our pointer instead of removing the next node.

You can't remove the current node.

The question states:

You have no other pointer to the list except the following links in each node.

This means that there are nodes prior to yours and, in particular, there is an immediately prior node that points to yours. You cannot delete your node because you have no way of changing the immediately prior node.

You can't remove the next node.

The question states that you need to remove:

the value stored in the node pointed to by p.

That's definitely not the value of the next node.

Answer 3

Summary

You will replace the node at the address of p with the next node in the list. When you start you have:

        +----+   +----+
        |    |   |    |
     -->|  p |-->|next|-->
        |    |   |    |
        +----+   +----+
        0x1234
        

After you replace the node at the current address you will have:

        +----+
        |    |
     -->|next|-->
        |    |
        +----+
        0x1234
        

Nothing prior to the address of p in the list changes. When you are done, you simply:

        delete p;

Detail

Your question setup tells you you have a pointer p to a node that is not the last node in your list and you need to remove the value at that node. Great, most of the work is already done, no need to iterate to find the node to remove. So how to make use of the current pointer to remove the value (actually replace the node at that address with the next node)?

Here you can make use of the address of the pointer p ( &p ) and the pointer to the next node ( p->next ) to copy the content of the next node to the present address, overwriting the current node contents with it. Since you haven't changed where the original pointer p points, it still points to the memory for the original node that was linked at the current address allowing you to free the memory using pointer p to complete the operation.

So what you want to do is first, replace the node at the current address in the list, eg

node **ppn = &p;               /* a pointer to pointer holding current address */

*ppn = p->next;                /* replace node at address of p with p->next */

(where p points to the current node, &p is the address for the pointer that is linked in your list, and p->next is a separate pointer to the next node in the list)

Since the previous next pointer still points to this address, and you have replaced the node at the current address with the next node in the list (whose next pointer still points to the correct following node), this is all that is required to remove the node that was original linked at p in the list.

To complete the process and avoid a memory leak, you need to free ( delete ) the memory for the node you removed. Since you have not changed where p itself points, it still points to the node you have removed from your list. So you can simply:

delete p;

and you are done.

It will take a minute to wrap your head around how you have used the address of p &p as a placeholder in your list, and you have simply replaced the node that was originally at that address in your list , with the next node in your list. This removes the node pointed to by p from the list. prev->next still points to the address of p and the new node you have assigned to that address still has a valid ->next pointer to the node that follows it in the list, so your list is complete sans one node. The pointer p still points to the memory holding the node that was removed, so you simply delete p; to tidy up.

That is what is explained in Linus on Understanding Pointers , though I never really loved that explanation as I found it a bit thin and awkwardly written.

Now you can take this knowledge and look at the del_node() and delnode() functions I pointed you to and begin digesting how it all works. It may take an hour or a day for the light-bulb to wink on and it all fall into place. That's fine. Thinking about how you can use both the address of a pointer as well as where the pointer points (eg the address it holds as its value) takes a bit of wrestling with to make peace with.

Full Example

A full example using:

*ppn = p->next;     /* replace node at address with next */
free (p);           /* delete current */

to remove the 4th node in a list of 1 - 10 using only p and its address:

#include <stdio.h>
#include <stdlib.h>

typedef struct node_t {
    int data;
    struct node_t *next;
} node_t;

/** add node at end of list, update tail to end */
node_t *add (node_t **head, int v)
{
    node_t **ppn = head,                    /* pointer to pointer to head */
            *pn = *head,                    /* pointer to head */
            *node = malloc (sizeof *node);  /* allocate new node */
 
    if (!node) {                            /* validate allocation */
        perror ("malloc-node");
        return NULL;
    }
    node->data = v;                         /* initialize members values */
    node->next = NULL;
 
    while (pn) {
        ppn = &pn->next;
        pn = pn->next;
    }
 
    return *ppn = node;    /* add & return new node */
}

/** print all nodes in list */
void prn (node_t *l)
{
    if (!l) {
        puts ("list-empty");
        return;
    }
    for (node_t *n = l; n; n = n->next)
        printf (" %d", n->data);
    putchar ('\n');
}

/** delete all nodes in list */
void del_list (node_t *l)
{
    node_t *n = l;
    while (n) {
        node_t *victim = n;
        n = n->next;
        free (victim);
    }
}

int main (void) {
    
    node_t *list = NULL, *p = NULL, **ppn = NULL;
    int node_to_rm = 4;
    
    for (int i = 0; i < 10; i++)
        if (!add (&list, i + 1))
            return 1;
    
    prn (list);
    
    /* iterate to find 4th node (with data = 5) */
    for (ppn=&list, p=list; p && node_to_rm; ppn=&p->next, p=p->next)
        node_to_rm--;
    
    *ppn = p->next;     /* replace node at address with next */
    free (p);           /* delete current */
    
    prn (list);
    del_list (list);
}

Example Use/Output

$ ./bin/ll_rm_single_node_given_p
 1 2 3 4 5 6 7 8 9 10
 1 2 3 4 6 7 8 9 10

Memory Use/Error Check

$ valgrind ./bin/ll_rm_single_node_given_p
==22684== Memcheck, a memory error detector
==22684== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==22684== Using Valgrind-3.13.0 and LibVEX; rerun with -h for copyright info
==22684== Command: ./bin/ll_rm_single_node_given_p
==22684==
 1 2 3 4 5 6 7 8 9 10
 1 2 3 4 6 7 8 9 10
==22684==
==22684== HEAP SUMMARY:
==22684==     in use at exit: 0 bytes in 0 blocks
==22684==   total heap usage: 11 allocs, 11 frees, 1,184 bytes allocated
==22684==
==22684== All heap blocks were freed -- no leaks are possible
==22684==
==22684== For counts of detected and suppressed errors, rerun with: -v
==22684== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)