STACKS AND QUEUES

1. STACKS AND QUEUES

2. data data data next next next NULL A LINKED LIST IMPLEMENTATION OF A QUEUE queue Queue: First-In-First-Out (FIFO) data structure cnt front rear node node node

3. The header file: queue.h #define EMPTY 0 #define FULL 10000 typedef int data; typedef enum {false, true} boolean; struct node { int d; struct node *next; }; typedef struct node node; struct queue { int cnt; /* count of the elements */ node *front; /* ptr to the front element */ node *rear; /* ptr to the rear element */ }; typedef struct queue queue;

4. The header file: queue.h data front(const queue *q); boolean isempty(const queue *q); boolean isfull(const queue *q); void initialize(queue *q); void enqueue(data x, queue *q); data dequeue(queue *q);

5. Basic queue routines : ISEMPTY(),ISFULL() boolean isempty(const queue *q) /* RETURNS TRUE IF QUEUE IS EMPTY */ { return ((boolean) (q -> cnt == EMPTY)); /* if(q->cnt==EMPTY) return true; else return false */ } boolean isfull(const queue *q) /* RETURNS TRUE IF QUEUE IS FULL */ { return ((boolean) (q -> cnt == FULL)); }

6. Basic queue routines : FRONT() , INITIALIZE() data front(queue *q) // RETURNS DATA OF FRONT NODE { return (q -> front -> d); } void initialize(queue *q) // Count=0, No front and rear nodes { q -> cnt = 0; q -> front = NULL; q -> rear = NULL; }

7. Basic queue routines : ENQUEUE() /* Creating queue enqueue */ void enqueue(data x, queue *q) { node *p; p = malloc(sizeof(node)); // CREATE A NEW NODE p -> d = x; p -> next = NULL; if (!isempty(q)) /* IF QUEUE IS NOT EMPTY APPEND NEW NODE FROM REAR */ { q -> rear -> next = p; q -> rear = p; } else /* IF QUEUE IS EMPTY NEW NODE WILL BE FRONT AND REAR */ q -> front = q -> rear = p; q -> cnt++; }

8. Basic queue routines : DEQUEUE() data dequeue(queue *q) { data x; node *p; x = q -> front -> d; /* store data in x */ p = q -> front; /* store address of front node that will be deleted */ q -> front = q -> front -> next; /* determine new front node */ q -> cnt- - ; /* decrease count */ free(p); /* free node */ return x; }

9. Basic queue routines :PRINT() void print(queue *q) { node * p; for(p=q->front; p!=NULL; p=p->next) printf("%d ", p->d); printf(“\n”); }

10. main() { queue my_q; data x; int op; initialize(&my_q); do { printf(" PLEASE SELECT OPERATION\n"); printf(" ENQUEUE 1\n DEQUEUE 2\n FRONT 3\n IS FULL 4\n IS EMPTY 5\n PRINT 6 \n EXIT 7\n " ); scanf("%d",&op); /* SWITCH- CASE  NEXT SLIDE */ } while(op!=7); }

11. switch(op) { case 1 : printf("Enter data : "); scanf("%d",&x); enqueue(x,&my_q); break; case 2: dequeue(&my_q); break; case 3: printf(" front: %d",front(&my_q)); break; case 4: if(isfull(&my_q)==true) printf("Queue is FULL"); else printf("Queue is NOT FULL"); break; case 5: /* similar to case 6 */ case 6: print(&my_q); break; case 7: exit(0); default : break; }

12. Array Implementation of Queues • An array to store elements, Array, and the positions Front and Rear to represent the ends of the queue are kept. • We also keep track of the number of elements: Size.

13. Array Implementation of Queues – Problem • To enqueue an element X, increment Size and Rear and set Array[Rear]=X • To dequeue an element, set the return value to Array[Front], decrement Size and then increment Front. • Assume after several enqueue operations, the Rear is at the last index position. Assume also that some elements, in the meantime, have been dequeued to make up room. The next enqueue would fail, although there would be free slots. 2 1 5 7 Front Rear

14. Array Implementation of Queues – Problem Solved • The simple solution is whenever Front or Rear gets to the end of the Array, it is wrapped around to the beginning (hence the name circular array). 2 1 2 1 2 3 4 4 4 Rear Rear Front Front Front Rear initially After enqueue(1) After enqueue(3)

15. QUEUE : Array Implementation #define MAX_QUEUE_SIZE 10 typedef struct { int cnt; int front; int rear; data[MAX_QUEUE_SIZE]; } queue;

16. QUEUES(array imp. ) : Basic routines void initializeQueue(queue * q) { q -> cnt = 0; q -> front = 0; q -> rear = -1; } boolean IsEmpty( queue * q ) { return q->cnt == 0; } boolean IsFull( queue * q ) { return q->cnt == MAX_QUEUE_SIZE; }

17. QUEUES(array imp. ) : Basic routines void enqueue(queue * q, int x){ if (!IsFull(q)){ q->rear++; q->cnt++; if (q->rear == MAX_QUEUE_SIZE) q->rear = 0; q->data [q->rear] = x; } }

18. QUEUES(array imp. ) : Basic routines int dequeue(queue * q){ if (!IsEmpty(q)){ int x=q->data[q->front]; q->cnt--; q->front++; if (q->front == MAX_QUEUE_SIZE) q->front= 0; return x; } }

19. STACKS • SAMPLE PSEUDO CODE: • push(1) to Stack • push(2) to Stack • push(3) to Stack • pop() from Stack • push(4) to Stack

20. STACKS : Array Implementation #define STACK_SIZE 4 typedef struct { int data [STACK_SIZE]; int top; } stack;

21. STACKS(array imp. ) : Basic routines void reset(stack * stk) { stk->top=-1; } void push( int c, stack * stk) { if(stk->top!= STACK_SIZE-1) { stk->top++; stk->data[stk->top]=c; } else printf(“Stack is full!!\n”); } int pop (stack * stk) { if(stk->top!=-1) return (stk->data[stk->top- -]) else printf(“stack is empty”); }

22. STACKS (array implementation): main() main() { stack n; int x; reset(&n); push(4,&n); push(5,&n); push(3,&n); push(2,&n); push(1,&n); x= pop(&n); push(11,&n); x= pop(&n); x= pop(&n); x= pop(&n); push(3,&n); push(2,&n); x= pop(&n); }

23. Stacks: Linked List Implementation

24. The header file: stack.h #define EMPTY 0 #define FULL 10000 typedef char data; typedef enum {false, true} boolean; typedef struct { data d; struct node *next; } node ; typedef struct { int cnt; /* count of the elements */ node *top; /* pointer to the top element */ } stack;

25. The header file: stack.h boolean empty(const stack *stk); boolean full(const stack *stk); void initialize(stack *stk); void push(data d, stack *stk); char pop(stack *stk); char top(stack *stk);

26. Basic routines : Isempty(),Isfull(), Initialize(), Top() boolean isempty(const stack *stk) { return (stk -> cnt == EMPTY); } boolean isfull(const stack *stk) { return (stk -> cnt == FULL); } void initialize(stack *stk) { stk -> cnt = 0; stk -> top = NULL; } data top(stack *stk) { return (stk -> top -> d); }

27. Basic routines : Push(),Pop() data pop(stack *stk) { data x; // will store the top data node *p; x = stk -> top -> d; p = stk -> top; stk -> top = stk -> top -> next; stk -> cnt- -; free(p); return x; } void push(data d, stack *stk) { /* create new node */ node *p; p = malloc(sizeof(node)); p -> d = d; p -> next = stk -> top; /* assign new node as top node */ stk -> top = p; stk -> cnt++; }

28. void main(void) { char str[] = “CS115”; int i; stack s; initialize(&s); /* initialize the stack */ for (i = 0; str[i] != '\0'; ++i) /* fill stack */ { if (!full(&s)) push(str[i], &s); } printf(“String in the stack: "); while (!empty(&s)) putchar(pop(&s)); }