The Bucharest University of Economic Studies. Data Structures. ADTs-Abstract Data Types Stacks and Queues

Size: px

Start display at page:

Download "The Bucharest University of Economic Studies. Data Structures. ADTs-Abstract Data Types Stacks and Queues"

Abel Sparks
6 years ago
Views:

1 The Bucharest University of Economic Studies Data Structures ADTs-Abstract Data Types Stacks and Queues

2 Agenda Definition Graphical representation Internal interpretation Characteristics Operations Implementations

3 Stack It is a linear structure in which the two basic operations, insertion and deletion are made on a LIFO based rule. These operations are made in a single part of the structure called the head of the stack, or the top. push STACK pop

4 Stack A logical structure implemented with different type of data structures: linked lists or arrays; A homogenous structure with elements of the same type; Basic operations: Adding an element, called the push operation Removing an element, called the pop operation Looking at the top element, called the peek operation struct Stack{ int Stack * }; info; next;

5 Stack as an ADT The implementation rule is LIFO Last In First Out The pop operation from a NULL stack is considered an error The push operation into a stack is considered a limitation The element from the top of a stack is the only accessible element top

6 Stack graphical representation push pop K C A T S Stack mechanism

7 Stacks with Linked Lists top of the stack new node 2 NULL NULL

8 Stacks with Linked Lists top of the stack NULL

9 Stacks with Linked Lists top of the stack temporary node NULL

10 Function call simulation 0x00f11464h int suma(int x, int y) { int z = 0, r = 2; z = x + y; return z; } void main(){ int a = suma(3,8); }

11 Function call simulation initialization. SP:0x0018FA18h BP:0x0018FA1Ch

12 Function call simulation push b b: 8. SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

13 Function call simulation push a a: 3 b: 8. SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

14 Function call simulation push IP IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

15 Function call simulation push BP BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

16 Function call simulation mov BP, SP BP:0x0018FA08h BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

17 Function call simulation sub r: 2 esp,8 SP:0x0018FA00h BP:0x0018FA08h z: 0 BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

18 Function call simulation mov r: 2 SP, BP SP:0x0018FA00h BP:0x0018FA08h z: 0 BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

19 Function call simulation pop r: 2 BP SP:0x0018FA00h BP:0x0018FA08h pop BP z: 0 BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

20 Function call simulation return BP:0x0018FA08h pop BP return r: 2 z: 0 BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA00h SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

21 Function call simulation BP:0x0018FA08h pop BP return r: 2 z: 0 BP: 0x0018FA1Ch IP: 0x00f11464h a: 3 b: 8. SP:0x0018FA00h SP:0x0018FA08h SP:0x0018FA0Ch SP:0x0018FA10h SP:0x0018FA14h SP:0x0018FA18h BP:0x0018FA1Ch

22 PUSH Pseudocode 1. memory allocation (newnode); 2. newnode initialization; 3. if (stack_full) stack overflow; else newnode >next = empty(head)? NULL: head; head = newnode;

23 POP Pseudocode 1. declaring a temporary node (tmpnode); 2. if (stack_empty) stack underflow; else value = head->info; tmpnode = head; head = head >next; free(tmpnode); return value;

24 QUEUES It is a linear structure in which the two basic operations, insertion and deletion are made on a FIFO based model. The insertion is made on the tail section and the deletion is made on the front section of the queue. dequeue get Queue put enqueue

25 Queue A logical structure implemented with different type of data structures: linked lists or arrays; A homogenous structure with elements of the same type; Basic operations: Adding an element, called the enqueuer or put operation Removing an element, called the dequeuer or get operation struct Queue{ Node* head; Node* tail; }; struct Node{ int Node * }; info; next;

26 Queue Implementation model FIFO Fifo In First Out front back

27 Queue Implementation put E U E U Q get

28 PUT Pseudocode 1. memory allocation for a new node (newnode); 2. newnode initialization; 3. if (full queue) queue overflow; else if (empty queue) head = tail = newnode ; else tail >next = newnode;

29 GET Pseudocode 1. declaring a temporary node (tmpnode); 2. if (empty queue) queue underflow; else value = head >info; tmpnode = head; head = head >next; free(tmpnode); return value;

30 Queues with Linked Lists head of the queue NULL tail of the queue 34 NULL

31 Queues with Linked Lists head of the queue tail of the queue 2 NULL

32 Queues with Linked Lists temporary node head of the queue tail of the queue 2 NULL

33 Queue Circular array Initial state (back < front && empty == true): back front

34 Queue Circular array Enqueue (2): 2 front back

35 Queue Circular array Enqueue (4): 2 4 front back

36 Queue Circular array Enqueue (1): back front

37 Queue Circular array Enqueue (3): back front

38 Queue Circular array Dequeue => return 2: back front

39 Queue Circular array Dequeue => return 4: front back

40 Queue Circular array Dequeue => return 1: back front

41 Queue Circular array Dequeue => return 3: back front

42 Palindrome Able was I ere I saw Elba

43 Ring buffer

44 Infix Postfix Prefix notations Evaluating mathematical expressions by using the stack data structure: reordering the elements so that the expression can be evaluated easily by one single crossing over the entire expression; The Polish notation invented by Jan Lukasiewicz also called the prefix expression; The Reverse Polish notation is called postfix notation.

45 Infix Postfix Prefix notations Evaluating mathematical expressions: Prefix or Polish notation: the operators are written before the operands Postfix or revers Polish notation: the operators are placed after the operands

46 Infix Postfix Prefix notations The postfix or the reverse Polish notation is much easily interpreted than the infix, normal mathematical expressions: the order of operations is straight forward; the parentheses are not necessary; the evaluation are automatically made by the use of a stack data structure;

47 Infix Postfix Prefix notations The algorithm for casting an infix expression to a postfix notation is called Dijkstra Shunting-Yard algorithm: using a stack for storing the operators in order to be transferred into the postfix notation; each operator has an adequate hierarchy level as depicted in the next table;

48 Infix Postfix Prefix notations Operators hierarchy level ( [ { ) ] } + - * /

49 Infix Postfix Prefix notations Mathematical expression (the infix notation) Polish notation (prefix expression) Reverse Polish notation (postfix expression) * * * + 4 * * * * (2 + 3) * *

50 Dijkstra Shunting-Yard algorithm Scan the entire infix expression from left to right for tokens (operators, operands and parentheses) For each token, test whether: If token is an operator: All operators from the top of the stack that are higher or equal precedence than the incoming one are popped out from the stack and appended to the postfix expression; after this operation the new token is pushed on the stack;

51 Dijkstra Shunting-Yard algorithm If token is an operand, append it to the postfix expression; If token is a left parenthesis, push it on the stack; If token is a right parenthesis: Pop all the operators from the stack and append them to the postfix expression, till the matching left parenthesis is found, which is popped out without being added to the result; When all tokens of the infix expression have been scanned, pop all the elements from the stack and append them to the postfix expression;

52 Infix to Postfix 2*(4+3)+9/3 Stack: Output:2

53 Infix to Postfix 2*(4+3)+9/3 Stack:* Output:2

54 Infix to Postfix 2*(4+3)+9/3 Stack:*( Output:2

55 Infix to Postfix 2*(4+3)+9/3 Stack:*( Output:24

56 Infix to Postfix 2*(4+3)+9/3 Stack:*(+ Output:24

57 Infix to Postfix 2*(4+3)+9/3 Stack:*(+ Output:243

58 Infix to Postfix 2*(4+3)+9/3 Stack:* Output:243+

59 Infix to Postfix 2*(4+3)+9/3 Stack:+ Output:243+*

60 Infix to Postfix 2*(4+3)+9/3 Stack:+ Output:243+*9

61 Infix to Postfix 2*(4+3)+9/3 Stack:+/ Output:243+*9

62 Infix to Postfix 2*(4+3)+9/3 Stack:+/ Output:243+*93

63 Infix to Postfix 2*(4+3)+9/3 Stack: Output:243+*93/+

64 Postfix evaluation algorithm Scan the entire postfix expression from left to right for tokens (operands and operators): For each token, test whether: If token is an operand is pushed on the stack; If token is an operator: The left element is popped from the stack into a x variable; The right element is popped from the stack into a y variable; The operation between x operator y is computed; The result is pushed on the stack; The last value standing on the stack is the result of the expression.

65 Infix->Postifix->Evaluation E = 2+5*3-(3*2+1)

66 Bibliografie Ion IVAN, Marius POPA, Paul POCATILU, coordonatori Structuri de date, Editura ASE, Bucuresti, 2008, ISBN Ion SMEUREANU Programarea in limbajul C/C++, Editura CISON, 2001 Michael MAIN Data Structures & Other Objects Using Java, Editura Pearson, 2012, ISBN:

The Bucharest University of Economic Studies. Data Structures. Heap Priority Queues Maps and Sets

The Bucharest University of Economic Studies Data Structures Heap Priority Queues Maps and Sets Heap A heap is a specialized tree-based data structure that satisfies the property: if A is parent for B