Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > comp.lang.c > #22573

Re: dequeue() not working

Show key headers only | View raw

arnuld wrote:
> 
> WANTED: to dequeue an element from Queue.
> GOT: nothing happening
> 
> /* A queue implementation with the operations that I need:
>  *  (1) Add an element to the front (head) of the queue
>  *  (2) Remove an element from rear (tail) of the queue
>  *  (2) remove an element with a unique ID (string constant)
>  *  (3) compare 2 elements (string comparison)
>  *  (4) print queue
>  *
>  * VERSION 0.0
>  */
> 
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
> 
> enum { SIZE_ID = 100, SIZE_ARR = 20, REPS = 3 };
> 
> struct myQ
> {
>   char id[SIZE_ID+1];
>   struct myQ* next;
> };
> 
> struct myList
> {
>   struct myQ* head;
>   struct myQ* tail;
> };
> 
> struct myList* allocmyList(void);
> int enqueue(struct myList* s, const char* id);
> struct myQ* dequeue(struct myList** s);
> void removeElement(struct myList* s, const char* id);
> struct myQ* searchElement(struct myList* s, const char* is, struct myQ**
> pr);
> void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev);
> void printQ(struct myList* s);
> /*void reverseQueue(struct myList** s); */
> 
> int main(void)
> {
>   struct myList* s = allocmyList();
>   int i;
>   for(i = 0; i < REPS; ++i)
>     {
>       int r;
>       char arrc[SIZE_ARR+1];
>       r = sprintf(arrc, "%d", i);
>       if(0 > r)
>         {
>           printf("ERROR-SPRINF() = %d\n", r);
>         }
>       else
>         {
>           enqueue(s, arrc);
>         }
>       printf("s->head = %p, s->tail = %p\n", (void*)s->head, (void*)s-
> >tail);
>     }
> 
>   printQ(s);
>   /*
>   for(i = 0; i < REPS; ++i)
>     {
>       int r;
>       char arrc[SIZE_ARR+1];
>       r = sprintf(arrc, "%d", i);
>       if(0 > r)
>         {
>           printf("ERROR-SPRINF() = %d\n", r);
>         }
>       else
>         {
>           removeElement(s, arrc);
>         }
>     }
>   */
>   dequeue(&s);
>   printQ(s);
>   free(s);
> 
>   return 0;
> }
> 
> int enqueue(struct myList* s, const char* id)
> {
>   struct myQ *p;
>   if(NULL == s || NULL == id) return -1;
>   p = malloc(1 * (sizeof *p));
>   if(NULL == p) return -1;
>   strcpy(p->id, id);
> 
>   if(s->head)
>     {
>       p->next = s->head;
>       s->head = p;
>     }
>   else
>     {
>       s->head = s->tail = p;
>     }
> 
>   return 1;
> }
> 
> struct myQ* dequeue(struct myList** s)
> {
>   struct myQ *temp, *prev;
>   if(NULL == s || NULL == *s) return 0;
>   if(NULL == (*s)->head) return 0;
>   prev = (*s)->head;
>   temp = (*s)->head;
>   if(NULL == (*s)->head->next)
>     {
>       struct myQ* retp = (*s)->head;
>       (*s)->head = (*s)->tail = NULL;
>       return retp;
>     }
> 
>   while(temp->next)
>     {
>       prev = temp;
>       temp = temp->next;
>     }
> 
>   (*s)->tail = prev;
> 
>   return temp;
> }
> 
> 
> void removeElement(struct myList* s, const char* id)
> {
>   struct myQ *p, *prev;
>   if(NULL == s || NULL == id) return;
>   p = searchElement(s, id, &prev);
>   if(p)
>     {
>       deleteElement(s, p, prev);
>     }
> }
> 
> struct myQ* searchElement(struct myList* s, const char* id, struct myQ**
> pr)
> {
>   struct myQ *prev, *cur;
>   prev = s->head;
>   for(cur = s->head; cur; cur = cur->next)
>     {
>       if(0 == strcmp(cur->id, id)) { *pr = prev; return cur;}
>       else prev = cur;
>     }
> 
>   return NULL;
> }
> 
> void deleteElement(struct myList* s, struct myQ* q, struct myQ* prev)
> {
>   if(0 == strcmp(s->head->id, q->id)) /* removing head */
>     {
>       s->head = q->next;
>       free(q);
>     }
>   else
>     {
>       prev->next = q->next;
>       free(q);
>     }
> }
> 
> void printQ(struct myList* s)
> {
>   if(s)
>     {
>       struct myQ* t;
>       for(t = s->head; t; t = t->next) printf("ID = %s\n", t->id);
>     }
>   else
>     {
>       printf("Nothing to print\n");
>     }
> 
>   printf("--------------------------------\n");
> }
> 
> 
> struct myList* allocmyList(void)
> {
>   struct myList* p = malloc(1 * (sizeof *p));
>   if(NULL == p) exit(EXIT_FAILURE);
>   p->head = NULL;
>   p->tail = NULL;
>   return p;
> }
> 
> /* --------------------------------------
> void reverseQueue(struct myList** s)
> {
>   return;
> }
> */
> 
> ========================= OUTPUT =============================
> /home/arnuld/programs/C $ gcc -ansi -pedantic -Wall -Wextra queue.c
> /home/arnuld/programs/C $ ./a.out
> s->head = 0x804a018, s->tail = 0x804a018
> s->head = 0x804a088, s->tail = 0x804a018
> s->head = 0x804a0f8, s->tail = 0x804a018
> ID = 2
> ID = 1
> ID = 0
> --------------------------------
> ID = 2
> ID = 1
> ID = 0
> --------------------------------
> /home/arnuld/programs/C $




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

enum { SIZE_ID = 100, SIZE_ARR = 20, REPS = 7 };

struct myQ {
    struct myQ *next;
    char id[SIZE_ID + 1];
};

struct myList {
    struct myQ *head;
    struct myQ *tail;
};

struct myQ *enqueue(struct myList *s, const char *id);
void printQ(struct myList *s);
void dequeue(struct myList *s);
struct myQ *searchElement(struct myList *s, const char *is);
void removeElement(struct myList *s, struct myQ *p);
void reverseQueue(struct myList *s);
void freequeue(struct myList *s);

int 
main(void)
{
    struct myList Mylist = {0};
    struct myList *s = &Mylist;
    int i;
    int r;
    struct myQ *temp;
    char arrc[SIZE_ARR + 1];

    for (i = 0; i < REPS; ++i) {        
        r = sprintf(arrc, "%d", i);
        if (0 > r) {
            printf("ERROR-SPRINF() = %d\n", r);
        } else {
            temp = enqueue(s, arrc);
            if (temp == NULL) {
                puts("\n\nenqueue(s, arrc) == NULL\n\n");                
                freequeue(s);
                break;
            }
            s -> head = temp;
            if (s -> tail == NULL) {
                s -> tail = s -> head;
            }
        }
        printf("s->head = %p, s->tail = %p\n", 
            (void*)s -> head, (void*)s -> tail);
    }    
    printQ(s);
    dequeue(s);
    printQ(s);
    dequeue(s);
    printQ(s);
    temp = searchElement(s, "3");
    if (temp != NULL) {
        puts(temp -> id);
        removeElement(s, temp);
        printQ(s); 
    } 
    temp = searchElement(s, "47");
    if (temp != NULL) {
        puts(temp -> id);
        removeElement(s, temp);
        printQ(s); 
    } 
    reverseQueue(s);
    printQ(s);
    reverseQueue(s);
    printQ(s);
    freequeue(s);
    printQ(s);
    return 0;
}   

struct myQ * 
enqueue(struct myList *s, const char* id)
{
    struct myQ *p;

    p = malloc(sizeof *p);
    if (p != NULL) {    
        p -> next = s -> head;
        strcpy(p -> id, id);
    }
    return p;
}  

void 
printQ(struct myList *s)
{
    if (s != NULL) {
        struct myQ *t;
        
        for (t = s -> head; t != NULL; t = t -> next) {
            printf("ID = %s\n", t -> id);
        }
    } else {
        puts("Nothing to print");
    }
    puts("--------------------------------");
}  

void 
dequeue(struct myList *s)
{ 
    struct myQ *cur;
    
    for (cur = s -> head; cur != NULL; cur = cur -> next) {
        if (cur -> next == s -> tail) { 
            break;
        }
    }
    if (cur != NULL) {
        cur -> next = NULL;
    }
    free(s -> tail);
    s -> tail = cur;
}

struct myQ *
searchElement(struct myList *s, const char *id)
{
    struct myQ *prev, *cur;
    
    prev = s -> head;
    for (cur = s -> head; cur; cur = cur -> next) {
        if (0 == strcmp(cur -> id, id)) { 
            break;
        }
    }
    return cur;
}

void 
removeElement(struct myList *s, struct myQ *p)
{
    struct myQ *prev, *cur;
    
    prev = s -> head;
    for (cur = s -> head; cur; cur = cur->next) {
        if (p == cur) { 
            break;
        }
        prev = cur;
    }
    if (cur != NULL) {
        prev -> next = cur -> next;
        free(cur);
    }
}

void 
reverseQueue(struct myList *s)
{
    struct myQ *head, *next_node, *previous;
    
    head = s -> tail = s -> head;
    if (head != NULL) {
        next_node = head -> next;
        head -> next = NULL;
        while (next_node != NULL) {
            previous = next_node -> next;
            next_node -> next = head;
            head = next_node;
            next_node = previous;
        }
    }
    s -> head = head;
}

void 
freequeue(struct myList *s)
{ 
    struct myQ *next, *cur;

    for (cur = s -> head; cur != NULL; cur = next) {
        next = cur -> next;
        free(cur);
    }
    s -> head = s -> tail = NULL;
}

-- 
pete

Back to comp.lang.c | Previous | Next — Previous in thread | Find similar | Unroll thread

Thread

dequeue() not working arnuld <sunrise@invalid.address> - 2012-06-21 07:11 +0000
  Re: dequeue() not working Ike Naar <ike@iceland.freeshell.org> - 2012-06-21 08:37 +0000
    Re: dequeue() not working Ike Naar <ike@iceland.freeshell.org> - 2012-06-21 08:42 +0000
      Re: dequeue() not working Ike Naar <ike@iceland.freeshell.org> - 2012-06-21 08:43 +0000
  Re: dequeue() not working Johann Klammer <klammerj@NOSPAM.a1.net> - 2012-06-21 11:09 +0200
    Re: dequeue() not working jgk@panix.com (Joe keane) - 2012-06-22 23:23 +0000
      Re: dequeue() not working Martin Shobe <martin.shobe@yahoo.com> - 2012-06-23 00:09 +0000
      Re: dequeue() not working Heikki Kallasjoki <fis+usenet@zem.fi> - 2012-06-23 00:10 +0000
      What's in a name? Johann Klammer <klammerj@NOSPAM.a1.net> - 2012-06-23 12:19 +0200
  Re: dequeue() not working Neil Cerutti <neilc@norwich.edu> - 2012-06-21 12:38 +0000
  Re: dequeue() not working pete <pfiland@mindspring.com> - 2012-06-23 00:39 -0400

csiph-web