Click here to Skip to main content
15,904,652 members
Please Sign up or sign in to vote.
0.00/5 (No votes)
See more:
del(int num)
    struct node *tmp,*q;
        start=start->next;  /*first element deleted*/
        start->prev = NULL;
        if(q->next->info==num)     /*Element deleted in between*/
    if(q->next->info==num)    /*last element deleted*/
    {   tmp=q->next;
    printf("Element %d not found\n",num);
}/*End of del()*/

Hello friends

I am trying to do doubly linked list program. I saw the code on[^] this site, but I did not under stand the delete operation but graphical vice I under stand the concept. Some commands I could not understand please help me friends.
Any one explain each line.
Updated 8-Oct-11 4:09am

Do you have any idea how much work is involved in "explain each line"?
Every single line would need a paragraph of text to explain it!
Ifg you want that much work done for you, then I suggest you ask on the site you got the code from...

All it is doing is pretty simple:
If the start of the list is the node you are looking for, delete it as a special case.
If it isn't, pass through the list to find the element to delete. If you find it, delete it.
If you don't find it, check if it is the final node and delete it as a special case if it is.

It's a bit rubbish - I wouldn't have written it that way - but it should work, provided there is more than one entry in the list. If there is one or zero entries in the list, I suspect it will fail fairly spectacularly. I'm not convinced that the final test is really needed, but as I say, I wouldn't have written it that way.
Share this answer
Mehdi Gholam 8-Oct-11 10:34am    
My 5!
Here's something I wrote a long time ago in straight C. I annotated the code as I wrote it so I wouldn't have to remember how it worked ever again. You might find the reading instructional on how to fiddle with double linked lists:

Header File
#pragma once

/* Useful Structures */

typedef struct tag_queue_entry {
    struct tag_queue_entry *qprev;  /* pointer to previous */
    struct tag_queue_entry *qnext;  /* pointer to next */
  } queue_entry_t;

typedef struct tag_queue_header {
    queue_entry_t *qfirst;      /* pointer to first */
    queue_entry_t *qlast;       /* pointer to last */
  } queue_header_t;

/* Function prototypes */

#ifdef _MSC_VER                                         /* MicroSoft C++ compiles, declare externals as "C" calling standard */
#ifdef __cplusplus
extern "C" {

void queue_insert(queue_entry_t *e, queue_header_t *h, queue_entry_t *t);   /* insert e into queue h after entry this */
void queue_remove(queue_entry_t *e, queue_header_t *h);             /* remove e from queue h */

#ifdef _MSC_VER
#ifdef __cplusplus

Code Body
#include "StdAfx.h"
#include <stdlib.h>			/* some good stuff */
#include "queueV2.h"		/* get symbols */

**	queue_insert()
**	Enters an element into a double threaded queue.
**	The queue header must be initialized to NULL and the
**	links are maintained so that a previous or next of NULL
**	indicates the end of the queue.
**	This always inserts after the "this" entry which permits:
**	  insert after this	queue_insert(e, h, this);
**	  insert at head	queue_insert(e, h, NULL);
**	  insert at tail	queue_insert(e, h, h->qlast);
**	  insert before this	queue_insert(e, h, this->qprev);

void queue_insert(queue_entry_t *e, queue_header_t *h, queue_entry_t *t)
	queue_entry_t *n;

	if (t == NULL)		/* if inserting at the head of the queue */
		n = h->qfirst;		/* next is old first */
		h->qfirst = e;		/* new is also first */
		n = t->qnext;		/* get this's next */
		t->qnext = e;		/* likewise, new is this's next */
	e->qprev = t;		/* new's prev is this (or NULL if first) */
	if ((e->qnext = n) == NULL)	/* point to old next, if now last */
		h->qlast = e;		/* store new last in queue */
	else n->qprev = e;	/* else new is next's prev */
} /* end of queue_insert() */

**	queue_remove()
**	Removes an element into a double threaded queue.

void queue_remove(queue_entry_t *e, queue_header_t *h)
	queue_entry_t *p;
	queue_entry_t *n;

	n = e->qnext;			/* remember next */
	if ((p = e->qprev) == NULL)		/* if this was the first (or only) */
		h->qfirst = n;			/* next is now first */
	else p->qnext = n;		/* else prev's next is old next */
	if (n == NULL)			/* if this was last (or only) */
		h->qlast = p;			/* prev is now last */
	else n->qprev = p;		/* else next's prev is old prev */
} /* end of queue_remove() */
Share this answer

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900