Data Structures Chapter 3 Stacks and Queues

Transcription

1 Data Structures Chapter 3 Stacks and Queues Instructor: Ching Chi Lin 林清池助理教授 chingchi.lin@gmail.com Department of Computer Science and Engineering National Taiwan Ocean University

2 Outline Stacks ( 堆疊 ) Queues( 佇列 ) A Mazing Problem ( 迷宮問題 ) Evaluation of Expressions ( 運算式計算 ) 2

3 Stacks Definition: A stack is an ordered list in which insertions (push/add) and deletions (pop/remove) are made at on end called top. ( 堆疊一種有序的串列, 僅在頂端進行插入和刪除的動作 ) The last element inserted into a stack is the first element removed. Last In First Out list, LIFO. ( 後進先出 ) top top top top top B C B D C B C B A A A A A D push push push pop 3

4 Stack Array Implementation The easiest way to implement this ADT is by using a one dimensional array. ( 使用陣列來實作堆疊最容易 ) a n-1... a 2 a 1 a 0 a 0 a 1 a 2... a n 2 a n 1 4

5 Functions for Stacks 1/2 Create Stack Create an empty stack whose maximum size is MAX_STACK_SIZE #define MAX_STACK_SIZE 100 /*maximum stack size*/ typedef struct{ int key; /* other fields */ } element; element stack[max_stack_size]; Int top = 1; IsEmpty Return TRUE if stack is empty and FALSE otherwise top < 0 5

6 Functions for Stacks 2/2 IsFull Return TRUE if stack is full and FALSE otherwise top >= MAX_STACK_SIZE 1; Add Insert item into top of the stack Delete Remove and return the item on the top of the stack 6

7 Program 3.1 Add to a stack void add (int *top, element item) { /* add an item to the global stack */ if (*top >=MAX_STACK_SIZE 1) { stack_full(); return; } stack[++*top]=item; } 7

8 Program 3.2 Delete from a stack element delete (int *top) { /* return the top element from the stack */ if (*top == 1) return stack_empty(); /* returns an error key */ return stack[(*top) ]; } 8

9 An Application of Stack: Stack Frame of Function Call stack frame: activation record ( 活動記錄 ) fp: a pointer to the current stack frame previous frame pointer return address a1 fp fp local variables previous frame pointer previous frame pointer return address main return address main system stack before a1 is invoked system stack after a1 is invoked 9

11 Queues Definition: A queue is an ordered list in which insertions take place at one end and all deletions take place at the opposite end. ( 佇列一種有序的串列, 插入發生在串列的一端, 刪除發生另一端 ) The first element inserted into a queue is the first element removed. First In First Out list, FIFO. ( 先進先出 ) add add delete rear front A rear front B A rear front C B A rear front C B A 11

12 Functions for Queues 1/2 Create Queue Create an empty queue #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; IsEmptyQ Return TRUE if the queue is empty and FALSE otherwise front == rear; 12

13 Functions for Queues 2/2 IsFullQ Return TRUE if the queue is full and FALSE otherwise rear == MAX_STACK_SIZE 1; AddQ Insert item at rear of queue and return queue DeleteQ Remove and return the item at front of queue 13

14 Program 3.3 Add to a queue void addq (int *rear, element item) { /* add an item to the queue */ if (*rear == MAX_QUEUE_SIZE 1) { queue_full(); return; } queue[++*rear] = item; } 14

15 Program 3.4 Delete from a queue element deleteq (int *front, int rear) { /* remove element at the front of the queue */ if (*front == rear) return queue_empty(); /*return an error key */ return queue[++*front]; } 15

16 Insertion and Deletion From a Sequential Queue Job scheduling The queue gradually shift to right. ( 佇列逐漸地向右移動 ) If rear index equals MAX_QUEUE_SIZE 1, suggesting that the queue is full. We should move the entire queue to the left: O(MAX_QUEUE_SIZE). front rear Q[0] Q[1] Q[2] Q[3] Comments 1 1 queue is empty 1 0 J1 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 16

17 Circular Queues 1/2 Straight line array >circle Initial circular queue: front = rear = 0; front: one position counterclockwise from the first element in the queue. ( 逆時鐘第一個元素的前一個位置 ) rear: current end of the queue. ( 目前最後的位置 ) J2 J J1 6 1 J3 J2 J front =0; rear=0 0 7 front =0; rear=3 0 7 front =5; rear=0 17

18 Circular Queues 2/2 A circular queue of size MAX_QUEUE_SIZE will be permitted to hold at most MAX_QUEUE_SIZE 1 elements. ( 最多只能儲存 MAX_QUEUE_SIZE 1 元素 ) The addition of such an element will result in front = rear and won t be able to distinguish between an empty and a full queue. ( 否則無法辨別它是一個空佇列或是一個滿載佇列 ) J2 J3 J4 J5 5 2 J5 J6 J7 5 1 J1 J7 J6 6 1 J4 J3 J2 J front =0; rear=7 0 7 front =5; rear=4 18

19 Program 3.5: Add to A Circular Queue void addq (int front, int *rear, element item) { /* add an item to the queue */ *rear = (*rear+1)% MAX_QUEUE_SIZE; if (front == *rear) { queue_full(rear); /* reset rear and print error */ return; } queue[*rear] = item; } 19

20 Program 3.6: Delete From a Circular Queue element deleteq (int *front, int rear) { element item; /* remove front element from the queue and put it in item */ if (*front == rear) return queue_empty(); /* queue_empty returns an error key */ *front = (*front+1)% MAX_QUEUE_SIZE; return queue[*front]; } 20

22 A Mazing Problem Example: find the path 0: paths 1: barriers Entrance Exit 22

23 Next Move Allowable moves NW [i 1][j 1] W [i][j 1] SW [i+1][j 1] N [i 1][j] X [i][j] S [i+1][j] typedef struct { short int vert; short int horiz; } offsets; offsets move [8]; NE [i 1][j+1] E [i][j+1] SE [i+1][j+1] Table of moves Name Dir Move[dir].vert Move[dir].horiz N NE E SE S SW W NW next_row = row + move[dir].vert; next_col = col + move[dir].horiz; 23

24 Initial Attempt at A Maze Traversal Algorithm A second two dimensional array, mark, records the maze positions already checked. ( 使用另一個二維陣列紀錄已檢查過的位置 ) Use a stack to save current path and direction. 24 ( 使用一個堆疊紀錄目前的路徑和方向 ) We can return to it and try another path if we take a hopeless path. The stack size is at most m n, which is the number of positions in the maze. #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];

25 Program 3.7: Initial Maze Algorithm Initialize a stack to the maze s entrance coordinates and direction to north; while (stack is not empty){ /* move to position at top of stack */ <row, col, dir> = delete from top of stack; while (there are more moves from current position) { <next_row, next_col > = coordinates of next move; dir = direction of move; if ((next_row == EXIT_ROW)&& (next_col == EXIT_COL)) success; if (maze[next_row][next_col] == 0 && mark[next_row][next_col] == 0) { /* legal move and haven t been there */ mark[next_row][next_col] = 1; /* save current position and direction */ add <row, col, dir> to the top of the stack; row = next_row; col = next_col; dir = north; } } Complexity: O(mn) } printf( No path found\n ); 25

26 Program 3.8: Maze Search Function 1/2 void path (void) { /* output a path through the maze if such a path exists */ int i, row, col, next_row, next_col, dir, found = FALSE; element position; mark[1][1] = 1; top =0; stack[0].row = 1; stack[0].col = 1; stack[0].dir = 1; while (top > 1 &&!found) { position = delete(&top); row = position.row; col = position.col; dir = position.dir; while (dir < 8 &&!found) { /*move in direction dir */ next_row = row + move[dir].vert; next_col = col + move[dir].horiz; if (next_row==exit_row && next_col==exit_col) found = TRUE; else if (!maze[next_row][next_col] &&!mark[next_row][next_col] { mark[next_row][next_col] = 1; 26

27 Program 3.8: Maze Search Function 2/2 } position.row = row; position.col = col; position.dir = ++dir; add(&top, position); row = next_row; col = next_col; dir = 0; } else ++dir; } } if (found) { printf( The path is :\n ); printf( row col\n ); for (i = 0; i <= top; i++) printf( %2d%5d, stack[i].row, stack[i].col); printf( %2d%5d\n, row, col); printf( %2d%5d\n, EXIT_ROW, EXIT_COL); } else printf( The maze does not have a path\n ); 27

29 Expressions 1/2 The representation and evaluation of expressions is of great interest to computer scientists. ( 計算機科學家對於運算式的表示法與計算方法感到有趣 ) Example: ((rear+1==front) ((rear==max_queue_size 1) &&!front)) operators : ==, +,,, &&,! ( 運算符號 ) operands: rear, front, MAX_QUEUE_SIZE ( 運算元 ) parentheses: (, ) ( 括號 ) 29

30 Expressions 2/2 Why expressions are important? For example, 1: * 5 =? 2: =? Case 1a: * 5 = 24 Case 2a: = 4 Case 1b: * 5 = 60 Case 2b: = 8 The difference between case 1a & case 1b Precedence rule ( 優先權法則 ) The difference between case 2a & case 2b Associative rule ( 關連性法則 ) Within any programming language, there is a precedence hierarchy that determines the order in which we evaluate operators. ( 任何程式語言都有一種用來決定計算符號先後順序的優先權等級 ) 30

31 Precedence Hierarchy for C How to generate the machine instructions corresponding to a given expression? ( 給定一個運算式如何產生相對應的電腦指令?) precedence rule + associative rule ( 優先權法則 + 關連性法則 ) The associativity column indicates how we evaluate operators with the same precedence. ( 相同優先權如何計算 ) 31

32 Evaluating Postfix Expressions 1/2 The standard way of writing expressions is known as infix notation. ( 運算式標準的寫法稱中序表示法 ) Place a binary operator in between its two operands. Ex: a + b It is not the one used by compilers to evaluate expressions. Instead compilers typically use postfix. ( 編譯器用後序表示法 ) Infix * 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 234*+ ab* * ab*c/ abc d+/ea *c* ab/c de*+ac* 32

33 Evaluating Postfix Expressions 2/2 Evaluating postfix expressions is much simpler than the evaluation of infix expressions. ( 計算後序運算式較容易 ) There are no parentheses and precedence to consider. To evaluate an expression we make a single left to right scan of it. We can evaluate an expression easily by using a stack. For example, the input is nine character string 6 2/3 4 2*+ 33

34 Postfix Evaluating : The Representations of Postfix Expression And Stack Expression is represented as a character array. The operators are +,, *, / and %. The operands are 0, 1, 2, 3, 4, 5, 6, 7, 8, and 9. The operands are stored on a stack of type int. The stack is represented by a global array accessed only through top. The declarations are: #define MAX_STACK_SIZE 100 /* maximum stack size */ #define MAX_EXPR_SIZE 100 /* max size of expression */ typedef enum {lparen, rparen, plus, minus, times, divide, mod, eos, operand} precedence; int stack[max_stack_size]; /* global stack */ char expr[max_expr_size]; /* input string */ 34

35 35

36 Program 3.10: Function to get a token from the input string precedence get_token(char *symbol, int *n) { /* get the next token, symbol is the character representation, which is returned, the token is represented by its enumerated value, which is returned in the function name */ } 36 *symbol =expr[(*n)++]; switch (*symbol) { case ( : return lparen; case ) : return rparen; case + : return plus; case : return minus; case / : return divide; case * : return times; case % : return mod; case \0 : return eos; default : return operand; /* no error checking, default is operand */ }

37 Infix to Postfix 1/4 Algorithm 1 Ex: a / b c + d * e a * c Step1: fully parenthesize the expression. ( 將運算式加上刮號 ) ((((a/ b) c)+(d*e)) (a*c)) Step2: move all binary operators so that they replace their corresponding right parentheses. ( 將運算符號取代其相對應的右刮號 ) ((((ab/c (de*+ac* Step3: delete all parentheses. ab/c de*+ac* 37

38 Infix to Postfix 2/4 Algorithm 2 Scan string from left to right ( 由左而右掃瞄 ) Operands are taken out immediately ( 遇到運算元立即輸出 ) Operators are taken out of the stack as long as their in stack precedence (isp) is higher than or equal to the incoming precedence (icp) of the new operator ( 運算符號的 isp 大於等於新的運算符號的 icp 時立即將它自堆疊中推出 ) If token == right parenthesis, unstack tokens until we reach the corresponding left parenthesis. ( 遇到 )" 將堆疊中運算元推出直到遇到相對應的 (") 38

39 Infix to Postfix 3/4 a + b * c Token a + b Stack [0] [1] [2] + + to p outpu t a a ab op ( ) + isp icp * + * 1 ab c eos + * 1 1 abc abc*+ * / % eos

40 Infix to Postfix 4/4 a * (b + c) * d toke n a * ( Stack [0] [1] [2] * * ( top output a a a op ( ) + isp icp b * ( 1 ab c ) * * ( + * ( + * * ab abc abc+ abc+* * / % d * 0 abc+*d eos 0 0 eos 1 abc+*d* 40

41 Complexity: Θ(n) The total time spent here is Θ(n) as the number of tokens that get stacked and unstacked is linear in n, where n is the number of tokens in the expression.