Queues and Lists

Alexander G. ChefranovCMPE-231 Spring 2012

1

Queue

A queue is an ordered collection of items from which items may be deleted from one end (called the front of the queue) and into which items may be inserted at the other end ( called the rear of the queue)

Insert(q,x) inserts item x at he rear of the queue qX=remove(q) deletes the front element of the

queue q and sets x to its contentsEmpty(q) returns false or true depending on

whether or not the queue contains any elements.

2

Queue (cont 1)

The remove operation can be applied only if the queue is nonempty. The result of illegal attempt to remove an element from an empty queue is called underflow

3

The Queue as ADTAbstract typedef <<eltype>> QUEUE(eltype);Abstract empty(q)QUEUE(eltype) q;Postcondition empty==(len(q)==0);Abstract eltype remove(q)QUEUE(eltype) q;Precondition empty(q)==FALSEPostcondition remove==first(q’); q==sub(q’,1,len(q’)-1);Abstract insert(q,elt)QUEUE(eltype) q;Eltype elt;Postcondition q=q’+<elt>;

4

Implementation of Queues#define MAXQUEUE 100Struct queue{ int items[MAXQUEUE]; int front, rear;} q;If array is used, overflow is possibleInsert(q,x): q.items[++q.rear]=x;X=remove(q): x=q.items[q.front++];Initially; q.rear=-1; q.front=0;The queue is empty when q.rear<q.frontThe number of elements is q.rear-q.front+1

5

Implementation of Queues (cont 1)With shifting:X=q.itemsp[0];For(i=0;i<q.rear;i++) q.items[i]=q.items[i+1];q.rear--;View an array as a circleAssume that q.front is the array index preceding the first

element of the queue rather than the index of the first element itself. Thus, since q.rear is the index of the last element of the queue, the condition q.front==q.rear implies that the queue is empty

Initialization: q.front=q.rear=MAXQUEUE-1;

6

Implementation of Queues (cont 2)Int empty(struct queue *pq){ return ((pq->front==pq->rear?TRUE:FALSE);}/*end empty*If(empty(&q)/*queue is emty*/Else /*not empty*/Int remove(struct queue *pq){ if(empty(pq)){printf(“queue underflow\n”); exit(1); }/*end if*/ if(pq->front==MAXQUEUE-1)pq->front=0; else (pq->front)++; return (pq->items[pq->front]);}/*end remove*/

7

Implementation of Queues (cont 3)Void insert(struct queue *pq, int x){ if (pq->rear==MAXQUEUE-1) pq->rear=0; else pq->rear++; /*check for overflow*/ if(pq->rear==pq->front){printf(“queue overflow\n”); exit(1); }/*end if*/ pq->items[pq->rear]=x; return;}/*end insert*/

8

Priority QueueThe priority queue is a data structure in which the intrinsic ordering of

the elements does determine the results of its basic operationsAn ascending (descending) priority queue is a collection of items into

which items can be inserted arbitrarily and from which only the smallest (largest) item can be removed

Pqinsert(apq,x), pqmindelete(apq);Pqinsert(dpq, x), pqmaxdelete(dpq);Empty(pq)Stack may be viewed as a descending priority queue whose elements

are ordered by time of insertionA queue may be viewed as an ascending priority queue whose

elements are ordered by time of insertion.In both cases, the time of insertion is not part of the elements

themselves but is used to order the priority queue

9

Array Implementation of a Priority Queue

Possible solutions to organize ascending queue1.A special empty symbol can be placed into a

deleted position2.A new item is inserted in the first empty

position3.Shifting after deletion4.Maintain the priority queue as an ordered,

circular array

10

Linked ListsLinear linked list: each item in the list is called a node and

contains two fields, an information field and a next address field (pointer)

The null pointer signals the end of the listThe list with no nodes is the empty list or null list: the external

pointer list=nullP is a pointer to a node, node(p) refers to the node pointed by

p, info(p) refers to the information portion of that node, next(p) refers to the next address portion and is therefore a pointer

If next(p) is not null, info(next(p)) refers to the information portion of the node that follows node(p) in the list

11

Inserting and Removing Nodes from a List

P=getnode() obtains an empty node and sets p to the address of that node

Insertion:Info(p)=x;Next(p)=list;List=p;

Deletion:P=list;List=next(p);X=info(p);Freenode(p);

12

Getnode and Freenode OperationsReal memory is finite and reuse is meaningfulP=getnode():If(avail==null){ printf(“overflow\n”); exit(1);}P=avail;Avail=next(avail);Freenode(p): next(p)=avail; avail=p;

13

Linked Implementation of QueuesX=remove(q):If(empty(q)){ printf(“queue underflow\n”); exit(1);}P=q.front;X=info(p);q.front=next(p);If(q.front==null)q.rear=null;Freenode(p);Return(x);

14

Linked Implementation of Queues (cont 1)

Insert(q,x):P=getnode();Info(p)=x;Next(p)=null;If(q.rear==null) q.front=p;Else next(q.rear)=p;q.rear=p;

15

Array Implementation of Lists#define NUMNODES 500Struct nodetype{ int info, next;};Struct nodetype node[NUMNODES];Initially, all nodes are unused:Avail=0;for(i=0;i<NUMNODES;i++) node[i].next=i+1;Node[NUMNODES-1].next=-1;Void getnode(void){ int p; if(avail==-1){ printf(“overflow\n”); exit(1); }

16

Array Implementation of Lists

P=avail;

avail=node[avail].next; return p;}/*end getnode*/Void freenode(int p){ node[p].next=avail; avail=p; return;}/*end freenode*/Void insafter(int p, int x){ int q; if(p==-1){ printf(“void insertion\n”); return; } q=getnode();

17

Array Implementation of Lists

node[q].info=x;

node[q].next=node[p].next; node[p].next=q; return;}/*end insafter*/Void delafter(int p, int *px){ int q; if((p==-1)||(node[p].next==-1)){ printf(“void deletion\n”); return; } q=node[p].next; *px=node[q].info; node[p].next=node[q].next; freenode(q); return;}

18

Linked Lists Using Dynamic Variables

struct node{ int info; struct node *next;};typedef struct node *NODEPTR;NODEPTR getnode(void){ NODEPTR p; p=(NODEPTR)malloc(sizeof(struct node)); return p;}Void freenode(NODEPTR p){ free(p);}

19

Linked Lists Using Dynamic Variables

void insafter(NODEPTR p, int x){ NODEPTR q; if(p==NULL){ printf(“void insertion\n”); exit(1); } q=getnode(); q->info=x; q->next=p->next; p->next=q;}/*end insafter*/

20

Linked Lists Using Dynamic Variables

void delafter(NODEPTR p; int *px){ NODEPTR q; if((p==NULL)||(p->next==NULL)){ printf(“void deletion\n”);exit(1); } q=p->next; *px=q->info; p->next=q->next; freenode(q);}

21

Queues as Lists in CStruct queue{ int front, rear’};Struct queue q;

Struct queue{ NODEPTR front, rear;};Struct queue q;

Int empty(struct queue *pq){ return((pq->front==-1) TRUE: FALSE);}/*end empty*/

Int struct(struct queue *pq){ return ((pq->front==NULL)?TRUE:FALSE);}/*end empty*/

Void insert(struct queue *pq, int x){ int p; p=getnode(); node[p].info=x; node[p].next=-1; if(pq->rear==-1) pq->front=p; else node[pq->rear].next=p; pq->rear=p;} /*end insert*/

Void insert(struct queue *pq, int x){ NODEPTR p; p=getnode(); p->info=x; p->next=NULL; if(pq->rear==NULL) pq->front=p; else (pq->rear)->next=p; pq->rear=p;}/*end insert*/

22

Queues as Lists in CInt remove(struct queue *pq){ int p,x; if(empty(pq)){ printf(“queue underflow\n”); exit(1); } p=pq->front; x=node[p].info; pq->front=node[p].next; if(pq->front==-1) pq->rear=-1; freenode((p); return x;}/*end remove*/

Int remove(struct queue *pq){ NODEPTR p; int x; if(empty(pq)){ printf(“queue underflow\n”); exit(1); } p=pq->front; x=p->info; pq->front=p->next; if(pq->front==NULL) pq->rear=NULL; freenode((p); return x;}/*end remove*/

23

Circular Lists

If the last node in a linear list refers to the first node then it is a circular list

Let an external pointer, p, refers to the last node in the list. Then the last node is node(p), and the first node is node(next(p))

24

Stack as a Circular List

Let stack be a pointer to the last node of a circular list and let the first node is the top of the stack

An empty stack is represented by a null listInt empty(NODEPTR *pstack){ return ((*pstack==NULL)?TRUE:FALSE);}/*end empty*/

25

Stack as a Circular List

Void push(NODEPTR *pstack, int x){ NODEPTR p; p=getnode(); p->info=x; if(empty(pstack)) *pstack=p; else p->next=(*pstack)->next; (*pstack)->next=p;}/*end push*/

26

Stack as a Circular ListInt pop(NODEPTR *pstack){ int x; NODEPTR p; if(empty(pstack)){ printf(“stack underflow\n”); exit(1); } p=(*pstack)->next; x=p->info; if(p==*pstack)/*only one node on the stack*/ *pstack=NULL; else (*pstack)->next=p->next; freenode(p); return x;}/*end pop*/

27

Queue as a Circular List

Using a circular list, a queue may be specified by a single pointer, q, to that list. Node(q) is the rear of the queue and the following node is the front

The function empty is the same as for stacks. The routine remove(pq) called by remove(&q) is identical to pop except that all references are to pstack are replaced by pq, a pointer to q.

28

Queue as a Circular ListVoid insert(NODEPTR *pq, int x){ NODEPTR p; p=getnode(); p->info=x; if(empty(pq)) *pq=p; else p->next=(*pq)->next; (*pq)->next=p; *pq=p; return;}/*end insert*/Note that insert(&q,x) is equivalent topush(&q,x);q=q->next;

29

Doubly Linked ListsStruct nodetype{ int info; int left, right;};Struct nodetype node[NUMNODES];

Struct node{ int info; struct node *left, *right;};Typedef struct node *NODEPTR;

30