STACK Data Structure:

Transcription

1 STACK Data Structure: Data Structures using C Chapter-3 STACK AND QUEUE A stack is an ordered list in which insertions and deletions are made at one end called the top. o If we add the elements A, B, C, D, E to the stack, in that order, then E is the first element we delete from the stack o A stack is also known as a Last-In-First-Out (LIFO) list. Fig: Insert and Delete Elements in the stack Primitive Operations on Stack push An item is added to a stack i.e. it is pushed onto the stack. pop An item is deleted from the stack i.e. it is popped from the stack. Working of stack: Stack, which contains max_size number of elements. The element item is inserted in the stack at the position top. Initially top is set to 1. Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 1

2 Since the push operation adds elements into a stack, the stack is also called as pushdown list. If there are no elements in a stack it is considered as empty stack. If the size of the stack is full then it is called stack overflow. The push operation is not applicable on full stack otherwise an overflow condition occurs. The pop operation is not applicable on an empty stack otherwise an underflow condition arises. We need to have a new operation empty(s) that checks whether a stack s is empty or not. Another operation on a stack is to determine what the top item of the stack is without removing it. stacktop(s) returns the top element of the stack s. Stack ADT: ADT Stack is objects: a finite ordered list with zero or more elements. functions: for all stack Stack, item element, max_stack_size positive integer Stack CreateS(max_stack_size) ::=create an empty stack whose maximum size is max_stack_size Boolean IsFull(stack, max_stack_size) ::=if(number of elements in stack == max_stack_size) return TRUE else return FALSE Stack Push(stack, item) ::=if(isfull(stack)) stack_fullelseinsert iteminto top of stackand returnabstract BooleanIsEmpty(stack) ::= if(stack == CreateS(max_stack_size)) return TRUE else return FALSE ElementPop(stack) ::= if(isempty(stack)) return Else remove and return the item on the top of the stack. Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 2

3 Implementation of stack: using array StackCreateS(max_stack_size)::= #define MAX_STACK_SIZE 100 /* maximum stack size */ typedefstruct int key; /* other fields */ element; element stack[max_stack_size]; //declaration of structure variable int top = -1; Boolean IsEmpty(Stack)::= top< 0; Boolean IsFull(Stack) ::= top >= MAX_STACK_SIZE-1; Add and Item to Stack: push() void push(element item) /* add an item to the global stack */ if (top >= MAX_STACK_SIZE-1) stackfull( ); return; stack[++top] = item; Delete an Item to Stack: pop() element pop() /* return the top element from the stack */ if (top == -1) return stackempty( ); /* returns and error key */ return stack[top--]; Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 3

4 Stack full: void stackfull() fprintf(stderr, Stack is full, cannot add element ); exit(exit_failre); StackCreateS()::= Stack Using Dynamic Arrays: #define MAX_STACK_SIZE 100 /* maximum stack size */ typedefstruct int key; /* other fields */ element; element *stack; //declaration of structure variable MALLOC (stack, sizeof(*stack)); int capacity=1; int top= -1; Boolean IsEmpty(Stack)::= top< 0; Boolean IsFull(Stack) ::= top >= capacity-1; Add and Item to Stack: push() void push(int *top, element item) /* add an item to the global stack */ if (*top >= MAX_STACK_SIZE-1) stackfull( ); return; stack[++*top] = item; Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 4

5 Delete an Item to Stack: pop() element pop(int *top) /* return the top element from the stack */ if (*top == -1) return stackempty( ); /* returns and error key */ return stack[(*top)--]; Stack full: void stackfull() fprintf(stderr, Stack is full, cannot add element ); exit(exit_failre); Queue Data Structure: A queue is an ordered list in which all insertion take place one end, called the rear and all deletions take place at the opposite end, called the front If we insert the elements A, B, C, D, E, in that order, then A is the first element we delete from the queue A Queue is also known as a First-In-First-Out (FIFO) list Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 5

6 Queue ADT: Structure Queue is objects: a finite ordered list with zero or more elements. functions: for all queue Queue, item element, max_ queue_ size positive integer Queue CreateQ(max_queue_size) ::= create an empty queue whose maximum size is max_queue_size Boolean IsFullQ(queue, max_queue_size) ::= if(number of elements in queue == max_queue_size) return TRUE else return FALSE QueueAddQ(queue, item) ::= if(isfullq(queue)) queue_full Else insert item at rear of queue and return queue Boolean IsEmptyQ(queue) ::= if(queue==createq(max_queue_size)) return TRUE else returnfalse ElementDeleteQ(queue) ::=if (IsEmptyQ(queue)) return Else remove and return the item at front of queue. Implementation of Queue using Arrays: Queue CreateQ(max_queue_size) ::= #define MAX_QUEUE_SIZE 100/* Maximum queue size */ typedef struct int key; /* other fields */ element; element queue[max_queue_size]; int rear = -1; int front = -1; Boolean IsEmpty(queue) ::= front == rear Boolean IsFullQ(queue) ::= rear == MAX_QUEUE_SIZE-1 Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 6

7 Add an Element to Queue: void addq(element item) /* add an item to the queue */ if (rear == MAX_QUEUE_SIZE-1) queuefull( ); queue [++rear] = item; queuefull() printf( Queue is Full ); return or exit(); Add an Element to Queue using Pointer: void addq(int *rear, element item) /* add an item to the queue */ if (*rear == MAX_QUEUE_SIZE-1) queuefull( ); return; queue [++*rear] = item; queuefull() printf( Queue is Full ); return or exit(); Delete from a Queue: element deleteq() /* remove element at the front of the queue */ if ( front == rear) return queueempty( ); /* return an error key */ return queue [++front]; Delete from a Queue using Pointer: element deleteq(int*front, intrear) /* remove element at the front of the queue */ if ( *front == rear) return queueempty( ); /* return an error key */ return queue [++ *front]; Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 7

8 Queue Empty: IsEmptyQ(queue) return (front == rear) Queue Full IsFullQ(queue) return rear == (MAX_QUEUE_SIZE-1) Applications of Queue: Queues, like stacks, also arise quite naturally in the computer solution of many problems. Perhaps the most common occurrence of a queue in computer applications is for the scheduling of jobs. In batch processing the jobs are ''queued-up'' as they are readin and executed, one after another in the order they were received. This ignores the possible existence of priorities, in which case there will be one queue for each priority. When we talk of queues we talk about two distinct ends: the front and the rear. Additions to the queue take place at the rear. Deletions are made from the front. So, if a job is submitted for execution, it joins at the rear of the job queue. The job at the front of the queue is the next one to be executed Solving Job Scheduling Algorithm using Queue data Structure in Operating System: creation of job queue - in the operating system which does not use priorities, jobs are processed in the order they enter the system. front rear Q[0] Q[1] Q[2] Q[3] Comments J1 queue is empty job 1 is added -1 1 J1 J2 job 2 is added -1 2 J1 J2 J3 job 3 is added 0 2 * J2 J3 job 1 is deleted 1 2 * * J3 job 2 is deleted Note: * representing empty Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 8

9 Problems with normal Queue: Queue gradually shifts to the right (as shown above in the job scheduling queue) queue_full(rear==max_queue_size-1) Queue_full does not always mean that there are MAX_QUEUE_SIZE items in queue there may be empty spaces available - Solution to save space: Circular queue Note: As the element in the queue are getting filled the rear getting incremented, but as the element getting deleted from the queue the front is also incrementing where we are wasting lots of memory without use of it as shown in the above fig of job scheduling. Circular Queues more efficient queue representation - Representing the array queue[max_queue_size] as circular - Initially front and rear to 0 rather than -1 - The front index always points one position counterclockwise from the first element in the queue - The rear index points to the current end of the queue empty queue Non empty Queue Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 9

10 Add to Circular Queue: void addq(element item) /* add an item to the queue */ rear = (rear +1) % MAX_QUEUE_SIZE; if (front == rear) /* reset rear and print error */ queuefull( ); queue[rear] = item; queuefull() printf( Queue is Full ); return or exit(); Delete from Circular Queue: element deleteq() element item; /* remove front element from the queue and put it in item */ if (front == rear) return queueempty( ); /* returns an error key */ front = (front+1) % MAX_QUEUE_SIZE; return queue[front]; queuefull() printf( Queue is Empty ); return or exit(); Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 10

11 Add to Circular Queue using Pointers: void addq(intfront, int*rear, element item) /* add an item to the queue */ *rear = (*rear +1) % MAX_QUEUE_SIZE; if (front == *rear) /* reset rear and print error */ queuefull( ); queue[*rear] = item; Delete from Circular Queue using Pointers: element deleteq(int* front, intrear) element item; /* remove front element from the queue and put it in item */ if (*front == rear) return queueempty( ); /* returns an error key */ *front = (*front+1) % MAX_QUEUE_SIZE; return queue[*front]; queuefull() printf( Queue is Empty ); return or exit(); Circular Queue using dynamically Allocated Arrays Suppose that a dynamically allocated array is used to hold the elements. Let capacity be the number of positions in the array queue. To add an element to a full queue, we must first increase the size of this array using the function realloc. As with dynamically allocated stacks, we use array doubling. However it isn t sufficient to simply double the array size using realloc. Consider the full queue as shown in fig (a). This figure shows the queue with seven elements I an array whose capacity is 8. To visualize array doubling when a circular queue used, it is better to flatten out the array as in fig (b). Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 11

12 Fig (c) shows the array after doubling by realloc. To get a proper circular queue configuration, we must slide the elements in the right segment (i.e. element A and B)to the right end of the array as in fig (d). To get the configuration as in fig (e) we must follow the following method: 1) Create a new array newqueue of twice the capacity. 2) Copy the second segment (i.e. the elements queue[front + 1] till queue[capacity-1])to positions in newqueue beginning at 0. 3) Copy the first segment (i.e. the elements queue[0] till queue[rear] to position in newqueue beginning at capacity-front-1) Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 12

13 Code showing Doubling queue capacity: Void queuefull() /* allocate an array with twice the capacity */ element * newqueue; MALLOC(newQueue, 2*capacity*sizeof(*queue)); /* copy from queue to newqueue*/ int start = (front + 1) % capacity; if(start < 2) copy(queue+start, queue+start+capacity-1, newqueue ); else copy(queue+start, queue+capacity, newqueue ); copy(queue, queue+rear+1, newqueue+capacity-start ); /* Switch to newqueue */ front = 2*capacity-1; rear = capacity-2; capacity = capacity * 2; free(queue); queue = newqueue; void addq(element item) /* add an item to the queue */ rear = (rear + 1)% capacity; if (front == rear) queuefull(); queue[rear] = item; Add a Circular Queue: Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 13

14 A Mazing Problem: The rat-in-a-maze experiment is a classical one from experimental psychology. A rat (or mouse) is placed through the door of a large box without a top. Walls are set up so that movements in most directions are obstructed. The rat is carefully observed by several scientists as it makes its way through the maze until it eventually reaches the other exit. There is only one way out, but at the end is a nice hunk of cheese. The idea is to run the experiment repeatedly until the rat will zip through the maze without taking a single false path. The trials yield his learning curve. We can write a computer program for getting through a maze and it will probably not be any smarter than the rat on its first try through. It may take many false paths before finding the right one. But the computer can remember the correct path far better than the rat. On its second try it should be able to go right to the end with no false paths taken, so there is no sense re-running the program. Why don't you sit down and try to write this program yourself before you read on and look at our solution. Keep track of how many times you have to go back and correct something. This may give you an idea of your own learning curve as we re-run the experiment throughout the book. Experiment implementation: the representation of the maze - Two-dimensional array - Element 0: open path - Element 1: barriers Let us represent the maze by a two dimensional array, MAZE(1:m, 1:n), where a value of 1 implies a blocked path, while a 0 means one can walk right on through. We assume that the rat starts at MAZE (1,1) and the exit is at MAZE(m,n). Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 14

15 With the maze represented as a two dimensional array, the location of the rat in the maze can at any time be described by the row, i, and column, j of its position. Now let us consider the possible moves the rat can make at some point (i,j) in the maze. Figure 3.6 shows the possible moves from any point (i,j). The position (i,j) is marked by an X. If all the surrounding squares have a 0 then the rat can choose any of these eight squares as its next position. We call these eight directions by the names of the points on a compass north, northeast, east, southeast, south, southwest, west, and northwest, or N, NE, E, SE, S,SW, W, NW. Note: We must be careful here because not every position has eight neighbors. If (i,j) is on a border where either i = 1 or m, or j = 1 or n, then less than eight and possibly only three neighbors exist. To avoid checking for these border conditions we can surround the maze by a border of ones. [row][col] which is on border - has only three neighbors - surround the maze by a border of 1 s Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 15

16 m * p maze - requires (m + 2) * (p + 2) array - entrance position: [1][1] - exit position: [m][p] Another device which will simplify the problem is to predefine the possible directions to move in a table, MOVE(1:8.1:2), which has the values Representation in C typedef struct short int vert; short int horiz; offsets; offsets move[8];/* array of moves for each direction */ Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 16

17 If we are at position, maze[row][col], and we wish to find the position of the next move, maze[row][col], we set: next_row = row + move[dir].vert; next_col = col + move[dir].horiz; Initial attempt at a maze traversal algorithm -dimensional array, mark, to record the maze positions already checked pass history #define MAX_STACK_SIZE 100 /*maximum stack size*/ typedef struct short int row; short int col; short int dir; element; element stack[max_stack_size]; Maze Search Algorithm: void path(void) int i, row, col, nextrow, nextcol, dir, found=false; element position; /* structure variable */ mark[1][1]=1; top=0; stack[0].row=1; stack[0].col=1; stack[0].dir=1; while(top > -1 &&!found) position = pop(); row = position.row; col=position.col; dir = position.dir; while(dir < 8 &&!found) /* move in direction dir*/ nextrow = row + move[dir].vert; nextcol = col + move[col].horiz; if(nextrow == EXIT_ROW && nextcol == EXIT_COL) found = TRUE; else if(!maze[nextrow][nextcol] = col &&!mark[nextrow][nextcol]) mark[nextrow][nextcol] = 1; position.row = row; position.col = col; position.dir = ++dir; push(position); row = nextrow; col = nextcol; dir = 0; Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 17

18 else ++ dir; if(found) printf( The Path is: ); printf( row col ); for(i=0; i<=top; i++) printf( %d%d, stack[i].row, stack[i].col); printf( %d%d, row, col); printf( %d%d, EXIT_ROW, EXIT_COL); else printf( The maze Does not have Path ); Evaluating postfix expressions ssions is known as infix notation binary operator in-between its two operands expressions referred to as postfix -free notation Postfix: - no parentheses, - no precedence Infix 2+3*4 a*b+5 (1+2)*7 a*b/c ((a/(b-c+d))*(e-a)*c a/b-c+d*e-a*c Postfix 2 3 4*+ ab* * ab*c/ abc-d+/ea-*c* ab/c-de*+ac*- Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 18

19 Evaluating postfix expressions is much simpler than the evaluation of infix expressions: Before attempting an algorithm to translate expressions from infix to postfix notation, let us make some observations regarding the virtues of postfix notation that enable easy evaluation of expressions. To begin with, the need for parentheses is eliminated. Secondly, the priority of the operators is no longer relevant. The expression may be evaluated by making a left to right scan, stacking operands, and evaluating operators using as operands the correct number from the stack and finally placing the result onto the stack. This evaluation process is much simpler than attempting a direct evaluation from infix notation. of it. we make a single left-to-right scan an expression easily by using a stack Evaluating Postfix Expression: 6 2/3-4 2*+ 6 2 / * + Token Stack [0] [1] [2] /2 6/2 3 6/2-3 6/ / /2-3 4*2 6/2-3+4*2 top Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 19

20 Representation expression #define MAX_STACK_SIZE 100 /* max stack size */ #define MAX_EXPR_SIZE 100 /* max expression size */ typedef enum lparen, rparen, plus, minus,times, divide, mode, eos, operand precedence; int stack[max_stack_size]; /* global stack */ char expr[max_expr_size]; /* input string */ Function to evaluate a postfix expression eval() - if the token is an operand, convert it to number and push to the stack - otherwise 1) pop two operands from the stack 2) perform the specified operation 3) push the result back on the stack function to get a token get_token() - used to obtain tokens from the expression string Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 20

21 int eval() precedence token; char symbol; int op1, op2; int n = 0; int top = -1; token = get_token(&symbol, &n); while (token!= eos) if (token == operand) push(&top, symbol- 0 ); else op2 = pop(&top); op1 = pop(&top); switch (token) case plus: push(&top, op1+op2); break; case minus: push(&top, op1-op2); break; case times: push(&top, op1*op2); break; case divide: push(&top, op1/op2); break; case mod: push(&top, op1%op2); // end of else token = get_token(&symbol, &n); // end of while return pop(&top); precedence get_token(char *psymbol, int *pn) *psymbol = expr[(*pn)++]; switch (*psymbol) case ( : return lparen; case ) : return rparen; case + : return plus; case - : return minus; case * : return times; case / : return divide; case % : return mod; case : return eos; default : return operand; /* no error checking */ Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 21

22 Converging Infix to Postfix Different possible algorithms for producing a postfix expression from an infix one 1) Fully parenthesize the expression 2) move all binary operators so that they replace their corresponding right parentheses 3) Delete all parentheses For eg) a/b-c+d*e-a*c when fully parenthesized it becomes ((((a/b)-c)+(d*e))-a*c)) Perform step-2 and step-3 on the above parenthesized expression we will get ab/c-de*+ac*- This procedure is easy to work only by hand but difficult to be done using a computer. The problem with this as an algorithm is that it requires two passes: The first one reads the expression and parenthesizes it while the second actually moves the operators. As we have already observed, the order of the operands is the same in infix and postfix. So as we scan an expression for the first time, we can form the postfix by immediately passing any operands to the output. Then it is just a matter of handling the operators. The solution is to PUSH them in a stack until just the right moment and then to POP from stack and pass them to the output. 1) Simple expression: Simple expression a+b*c - yields abc*+ in postfix token a + b * c eos Stack [0] [1] [2] * + * top Output a a ab ab abc abc*+ Translation of a+b*c to postfix Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 22

23 Parenthesized expression Parentheses make the translation process more difficult - equivalent postfix expression is parenthesis-free expression a*(b+c)*d - yield abc+*d* in postfix right parenthesis - pop operators from a stack until left parenthesis is reached Token a * ( b + c ) * d eos Stack [0] [1] [2] * * ( * ( * ( + * ( + * * * * top output a a a ab ab abc abc+ abc+* abc+*d abc+*d* Translation of a*(b+c)*d to postfix Postfix: - no parenthesis is needed - no precedence is needed Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 23

24 Function to concert infix to postfix: void postfix(void) char symbol; precedence token; int n = 0; int top = 0; stack[0] = eos; for (token = get_token(&symbol, &n); token!= eos; token = get_token(&symbol, &n)) if (token == operand) printf( %c, symbol); else if (token == rparen) while (stack[top]!= lparen) print_token(pop(&top)); pop(&top); else while (isp[stack[top]] >= icp[token]) print_token(pop(&top)); push(&top, token); while ((token = pop(&top))!= eos) print_token(token); printf( \n ); Lecturer: Syed Khutubuddin Ahmed Contact: khutub27@gmail.com 24