removing link.

I can't remember how I removed things from linked list, here is what I am getting at.

get to link to remove
copy everything from the next link into current link, and then advance and repeat until reach end.

if anyone can help refresh memory, that would be greatful

Code:

node * detach(node * n)
{
 n->next->prev = n->prev;
 n->prev->next = n->next;
 n->next = n->prev =  0;
 return n;
}

You will also want to free() the memory allocated for the struct you are deleting.

before n->next = n->prev = 0;
you shuld do this:
free(n);

Well, copying bytes of memory is what the linked list is intended to avoid.

what do you mean by this?
>>Well, copying bytes of memory is what the linked list is intended to avoid.

He means that linked lists are designed to be non-contiguous, to stop having to repeatedly realloc etc, stop moving data around memory.

You should link and unlink by pointer, not move data around, it defeats the purpose a little and it's not efficient.

yeah, I realized that when I saw the 1st reply.

Actually, the code I posted is faulty and should be:

node * detach(node * n)
{
if(n->next)n->next->prev = n->prev;
if(n->prev)n->prev->next = n->next;
n->next = n->prev = 0;
return n;
}

Originally posted by paolo_maldini
before n->next = n->prev = 0;
you shuld do this:
free(n);

Not quite. After you free() an object, you should consider it off-limits to any further accesses.

Anyway, a detach() function is mainly for rearranging nodes, though it could be used for erasing nodes too.

A more efficient approach might be:

Code:

node * detach(node * begin, node * last)
{
 if(begin->prev)begin->prev->next = last->next;
 if(last->next)last->next->prev = begin->prev;
 last->next = begin->prev =  0;
 return begin;
}


node * detach_node(node * n)
{
 return detach(n, n);
}


void erase(node * begin, node * last)
{
 node * seg = detach(begin, last);
 node * goner = seg;
 while(seg)
 {
  goner = seg;
  seg = seg->next;
  free(goner);
 }
}


node * head(node * n)
{
 node * first = n;
 while(first->prev) first = first->prev;
 return first; 
}


node * tail(node * n)
{
 node * last = n;
 while(last->next) last = last->next;
 return last; 
}

// free the entire list from any node // 

void free_list(node * anywhere)
{
 erase(head(anywhere), tail(anywhere));
}

Some further reading for you.