Data Structure - Stack and Queue-

Size: px

Start display at page:

Download "Data Structure - Stack and Queue-"

Calvin Hoover
6 years ago
Views:

1 Data Structure - Stack and Queue- Hanyang University Jong-Il Park

2 STACK

3 Stack ADT List that insertions and deletions can be performed at the end of the list Operations Push(X, S): insert X in the list S Pop(S): deletes the most recently inserted element from S Push(X, S) Pop(S) = X X 3 Top(S) 2 1 stack S Push(1, S) Push(2, S) Push(3, S) Push(X, S)

4 Stack ADT: linked list implementation struct Node; typedef struct Node *PtrToNode; typedef PtrToNode Stack; struct Node{ ElementType Element; PtrToNode Next; };

5 Stack ADT: linked list implementation Stack CreateStack (void){ Stack S; } S = malloc(sizeof (struct Node)); if (S == NULL) FatalError( Out of space!!! ); MakeEmpty(S); return S; void MakeEmpty(Stack S) { if (S == NULL) Error ( Must use CreateStack first ); else while(!isempty(s)) Pop(S); }

6 Stack ADT: linked list implementation Push(ElementType X, Stack S) A 3 header A3 A2 A1 A 2 S Push(X, S) A 1 header X A3 A2 A1 X A 3 S A 2 A 1

7 Stack ADT: linked list implementation header A3 A2 A1 S header X A3 A2 A1 S void Push (ElementType X, Stack S) { PtrToNode TmpCell; TmpCell = malloc (sizeof (struct Node)); if (TmpCell ==NULL) FatalError( Out of space!!! ); else { TmpCell -> Element = X; TmpCell -> Next = S -> Next; S -> Next = TmpCell; } Division 7 of Computer Science and Engineering, Hanyang University }

8 Stack ADT: linked list implementation Pop(Stack S) A 3 header A3 A2 A1 A 2 S Pop(S) A 1 header A2 A1 S A 2 A 1

9 Stack ADT: linked list implementation ElementType Top (Stack S) { if (!IsEmpty(S)) return S->Next->Element; Error ( Empty stack ); return 0; } void Pop (Stack S) { PtrToNode FirstCell; } if (IsEmpty(S)) Error( Empty stack ); else{ FirstCell = S->Next; S->Next = S->Next->Next; free(firstcell); }

10 Stack ADT: array implementation typedef struct StackRecord *Stack; struct StackRecord { int Capacity; int TopOfStack; ElementType *Array; }; Capacity TopOfStack Array

11 Stack ADT: array implementation #define EmptyTOS ( -1 ) #define MinStackSize ( 5 ) Stack CreateStack( int MaxElements ) { Stack S; if( MaxElements < MinStackSize ) Error( Stack size is too small ); S = malloc( sizeof( struct StackRecord ) ); if( S == NULL ) FatalError( Out of space!!! ); S->Array = malloc( sizeof( ElementType ) * MaxElements ); if( S->Array == NULL ) FatalError( Out of space!!! ); S->Capacity = MaxElements; MakeEmpty( S ); } return S; Division 11 of Computer Science and Engineering, Hanyang University

12 Stack ADT: array implementation void MakeEmpty( Stack S ) { S->TopOfStack = EmptyTOS; } void Push( ElementType X, Stack S ) { if( IsFull( S ) ) Error( Full stack ); else S->Array[ ++S->TopOfStack ] = X; } Division 12 of Computer Science and Engineering, Hanyang University

13 Stack ADT: array implementation ElementType Top( Stack S ) { if(!isempty( S ) ) return S->Array[ S->TopOfStack ]; Error( Empty stack ); return 0; /* return value used to avoid warning */ } void Pop( Stack S ) { if( IsEmpty( S ) ) Error( Empty stack ); else S->TopOfStack--; } Division 13 of Computer Science and Engineering, Hanyang University

14 Example 3.1 [system stack] place an activation record or a stack frame on top of the system stack the activation record for the invoked function contain a pointer to the previous stack frame and a return address(program counter) on top of the system stack : one function executed at any given time

15 Eg. System stack 1 int main() { int i=3; 20 fcn1(i); } 100 int fcn1(int a) { int j=5 150 fcn2(j); } 200 void fcn2(int b) { } fcn2 PC=200 b=5 fcn1 PC=100 a=3 fcn1 PC=150 a=3,j=5 fcn1 PC=151 a=3,j=5 main PC=1 main PC=20 main PC=20 main PC=20 main PC=21

16 EVALUATION OF EXPRESSIONS

17 Parentheses Matching

18 Parentheses Matching scan expression from left to right when a left parenthesis is encountered, add its position to the stack when a right parenthesis is encountered, remove matching position from stack

19 Example

20 Example

21 Example

22 Example

23 Example

24 Evaluation of Expressions Expressions X = A / B - C + D * E - A * C to fix the order of evaluation, assign to each operator a priority A = 4, B = C = 2, D = E = 3 Interpretation 1: ((4/2)-2) + (3*3) (4*2) = = 1 Interpretation 2: (4/(2-2+3))*(3-4)*2 = (4/3)*(-1)*2 = How to generate the machine instructions corresponding to a given expression?

25 infix, prefix, postfix notation infix * 6? (3 + 4) * 6? 3 + (4 * 6) prefix * (3 + 4) * * (4 * 6) * (3 + 4) * 6 postfix * (4 * 6) Division 25 of Computer Science and Engineering, Hanyang University

26 evaluation of postfix expression * / + 2 * 3 = / = / = / + 9 / 3 = = 4 Division 26 of Computer Science and Engineering, Hanyang University

27 Stack ADT: postfix expression * * TopOfStack * * Division 27 of Computer Science and Engineering, Hanyang University

28 Infix to postfix an algorithm for producing postfix from infix 1) fully parenthesize the expression 2) move all operators for replacing their corresponding right parentheses 3) delete all parentheses infix: A / B - C + D * E - A * C when fully parenthesized: ((( A / B ) - C ) + ( D * E )) - ( A * C )) postfix: A B / C - D E * + A C * -

29 Stack ADT: infix to postfix conversion a+b*c+(d*e+f)*g abc*de*f+g*+ stack * * ( ( output a a a b a b a b c a b c * a b c * + a b c * + a b c * + d * * + + ( ( ( ( ( a b c * + d a b c * + d e a b c * + d e * a b c * + d e * a b c * + d e * f a b c * + d e * f + * * a b c * + d e * f + a b c * + d e * f + g a b c * + d e * f + g * a b c * + d e * f + g * +

30 Eg. Infix to postfix if the input expression is empty, then output all remaining operators in the stack infix: A + B * C next token stack output none empty none A empty A + + A B + AB * +* AB C +* ABC done empty ABC*+

31 Infix to postfix (Cont.) a priority-based scheme for stacking and unstacking operators establish two priorities for operators : isp(in-stack priority) and icp(in-coming priority) isp( '(' ) = 0, icp( '(' ) = 20, isp( )' ) = 19 priority operator 0 ( 19 ) * 13 / 13 % 0 eos Priority of operations in C stacking rule : operators are taken out of the stack as long as their in-stack priority is numerically greater than or equal to the in-coming priority of the new operator

32 Infix to postfix (Cont.) /* isp and icp arrays -- index is value of precedence lparen, rparen, plus, minus, times, divide, mod, eos */ static int isp [ ] = {0, 19, 12, 12, 13, 13, 13, 0}; static int icp [ ] = {20, 19, 12, 12, 13, 13, 13, 0};

33 QUEUE

34 Queue ADT a list that insertions is done at one end, whereas deletion is performed at the other end operations enqueue: inserts an element at the end of the list dequeue: deletes the element at the start of the list dequeue enqueue front rear

35 Queue ADT: circular array when front or rear gets to the end of the array, it is wrapped around to the beginning 2 4 front rear enqueue(1) enqueue(3) dequeue( ) dequeue( ) dequeue( ) 1 3 dequeue( )

36 Queue ADT: circular array check the queue for emptiness because a dequeue() when the queue is empty will return an undefined value silently dequeue enqueue front rear Division 36 of Computer Science and Engineering, Hanyang University

37 Queue ADT: circular array struct QueueRecord; typedef struct QueueRecord *Queue; struct QueueRecord{ int Capacity; int Front; int Rear; int Size; ElementType *Array; }; Division 37 of Computer Science and Engineering, Hanyang University

38 Queue ADT: array implementation void MakeEmpty (Queue Q){ Q -> Size = 0; Q -> Front = 1; Q -> Rear = 0; } static int Succ(int Value, Queue Q){ if (++Value == Q->Capacity) Value = 0; return Value; } void Enqueue (ElementType X, Queue Q){ if (IsFull(Q)) Error( Full queue ); else { Q -> Size++; Q -> Rear = Succ(Q->Rear, Q); Q -> Array[Q->Rear] = X; } Division 38 of Computer Science and Engineering, Hanyang University

39 Circular Queues Using Dynamically Allocated Array B A front = 5 C D E rear = 4 (a) A full circular queue queue [0] [1] [2] [3] [4] [5] [6] [7] C D E F G A B F G front = 5, rear = 4 (b) Flattened view of circular full queue [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] C D E F G A B front = 5, rear = 4 (c) After array doubling

40 Circular Queues Using Dynamically Allocated Array [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] C D E F G A B front = 13, rear = 4 (d) After shifting right segment [0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12] [13] [14] [15] A B C D E F G front = 15, rear = 6 (e) Alternative configuration Figure 3.7: Doubling queue capacity

41 The Queue Abstract Data Type (Cont.) Doubling queue capacity (1) Create a new array newqueue of twice the capacity. (2) Copy the second segment (i.e., the elements queue[front+1] through queue[capacity-1]) to positions in newqueue beginning at 0. (3) Copy the first segment (i.e., the elements queue[0] through queue[rear]) to positions in newqueue beginning at capacity-front-1.

42 The Queue Abstract Data Type (Cont.)

43 The Queue Abstract Data Type (Cont.)

DATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently.

DATA STRUCUTRES. A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. DATA STRUCUTRES A data structure is a particular way of storing and organizing data in a computer so that it can be used efficiently. An algorithm, which is a finite sequence of instructions, each of which