Computer Science BS Degree - Data Structures (I2206) Abstract Data Types (ADT)

Size: px

Start display at page:

Download "Computer Science BS Degree - Data Structures (I2206) Abstract Data Types (ADT)"

Felix Hines
5 years ago
Views:

1 Abstract Data Types (ADT) 70

2 Hierarchy of types Each type is implemented in terms if the types lower in the hierarchy Level 0 Bit Byte Word Level 1 Integer Real Char Boolean Pointer Level 2 Array Record Level 3 Tree List Stack Set Graph Data types Data Structures Abstract Data Types is composed of 71

3 Introduction Ideal: to have a high level language with all abstract data types built in, in the same way that arrays and records are built into C. Difficulty: for most abstract data types, there is no unique and efficient implementation. It is left to the programmer to define abstract data types and provide implementation for them in terms of the hierarchy of types of a language (such as C). 72

4 Introduction Once an ADT is specified and implemented, it can be used like any other built-in type with no reference to its particular implementation. To specify an ADT: Never think about implementation Think about the types applicable operations Think about formal properties linking these operations 73

5 Stacks 74

6 What is a Stack? A stack is a linear ADT. The order in which data arrives is important Definition: A stack is an ordered list in which insertion and deletion are done at one end (called top). The last element inserted is the first one to be deleted. Last In First Out (LIFO) or First In Last Out (FILO). 75

7 What is a Stack? push: insert an element in a stack pop: remove an element in a stack Underflow: pop out an empty stack Push A Push B Push C Push D Pop Push E top DE C B A 76

8 Stack ADT The following operations make a stack an ADT. Main stack operations: Create_stack: Create of an empty stack. Push: Insert data onto stack. Pop: Remove the last inserted element from the stack. Auxiliary stack operations: Top: returns the last inserted element without removing it. Size: returns the number of elements stored in stack. isemptystack: indicates whether any elements are stored in stack or not. 77

9 Exceptions Pop and top operations cannot be performed if the stack is empty. Attempting the execution of pop / top on an empty stack throws an exception. 78

10 Applications Direct applications: Balancing of symbols Infix-to-postfix expression Evaluation of postfix expression Implementing function calls (including recursion) Finding of spans Page visited history in a Web browser (back button) Undo sequence in a text editor Matching Tags in HTML and XML Indirect applications: Auxiliary data structure for other algorithms (example: Tree traversal algorithms) Component of other ADTs (example: simulating queues) 79

11 Formal description of a STACK Informal descriptions do not suffice. An abstract data type specification will show precisely how operations can be used It consists of four paragraphs: TYPES FUNCTIONS AXIOMS PRECONDITIONS 80

12 1* TYPES Indicates the types being specified Example Type: Stack Parameter: Element Use: Boolean Genericity Parameter is called a formal generic parameter of the abstract data type Stack, and Stack itself is said to be a generic ADT. 81

13 2* FUNCTIONS lists the operations applicable to instances of the ADT does not fully define these functions; it only introduces their signatures the list of their argument and result types. Functions: Create_stack : Stack isemptystack : Stack Boolean Push : Element Stack Stack Pop : Stack Stack Top : Stack Element Usage examples Create_stack() isemptystack(s) Push(El, S) Pop(S) Top(S) 82

14 Function categories Creators: Create a new instance of an ADT from instances of other types or from no argument at all. {OTHERS} ADT Queries: Functions that have a return value and do not change the instance. ADT {x OTHERS} OTHERS Commands: Functions without return value that change the instance. ADT {x OTHERS} ADT Constructors: Creators + Commands that add elements the ADT 83

15 3* AXIOMS Axioms that the ADT fulfills. Because any explicit definition would force us to select a representation, we must turn to implicit definitions. Refrain from giving the values of the functions of an ADT specification; instead state properties of these values all the properties that matter. Axioms: Let p be a Stack and e an Element: - isemptystack(create_stack()) = True - isemptystack(push(p,e)) = False - Pop(Push(p,e)) = p - Top(Push(p,e)) = e 84

16 Partial functions Some operations are not applicable to every possible element of their source sets. You cannot pop an element from an empty stack; An empty stack has no top. A function from a source set X to a target set Y is partialif it is not defined for all members of X. A function which is not partial is total. Example: division by 0. To indicate that a function may be partial, the notation uses the crossed arrow ; the normal arrow will be reserved for functions which are guaranteed to be total. The domainof a partial function in X Y is the subset of Xcontaining those elements for which the function yields a value. Example: for the inverse function, R\{0} is the domain. 85

17 4* PRECONDITIONS Preconditions that need to be fulfilled to apply a feature.\ Role of the PRECONDITIONS paragraph : Any ADT specification which includes partial functions must specify the domain of each of them. Preconditions: Let p be a Stack: Pop(p) is defined iffnot isemptystack(p) Top(p) is defined iffnot isemptystack(p) 86

18 Stack ADT Type: Stack Parameter: Element Use: Boolean Functions: Create_stack : Stack isemptystack : Stack Boolean Push : Element Stack Stack Pop : Stack Stack Top : Stack Element Constructors: Create_stack and Push top D C B A Push(D, Push(C, Push(B, Push(A, Create_stack() ) ) ) ) 87

19 Stack ADT Preconditions: Let p be a Stack: Pop(p) is defined iffnot isemptystack(p) Top(p) is defined iffnot isemptystack(p) Axioms: Let p be a Stack and e an Element: - isemptystack(create_stack()) = True - isemptystack(push(p,e)) = False - Pop(Push(p,e)) = p - Top(Push(p,e)) = e 88

20 Well-formed and correct terms Well-formed: all functions get a right number of arguments of right types Correct: preconditions of all functions are satisfied Examples: isemptystack(top(push(create_stack(), 3))) Top(Push(Create_stack(), 3)) 3 Top(Pop(Push(Create_stack(), 3))) isemptystack(pop(push(create_stack(), 7))) Top(Push(Push(Pop(Push(Create_stack(), 4)), 3), 2)) 2 ill-formed incorrect True 89

21 Sufficient completeness The specification contains axioms powerful enough to enable us to find the result of any query expression, in the form of a simple value. An ADT is sufficiently complete if and only if: 1. For every term t you can determine whether it is correct or not using the axioms of the ADT. 2. Every correct term where the outermost function is a query of the ADT can be reduced, using the axioms of the ADT, into a term not using any function of the ADT. In Rule 2, tem t is of the form (,, )where f is a query function, such as isemptystackand Top for stacks. Rule 1 tells us that t has a value, but this is not enough; in this case we also want to know what the value is, expressed only in terms of values of other types (in the STACK example, values of types BOOLEAN and ELEMENT). If the axioms are strong enough to answer this question in all possible cases, then the specification is sufficiently complete. 90

22 Implementation Many ways of implementing stack ADT: 1. Static (array) based implementation 2. Dynamic (Linked lists) based implementation

23 Header files 92

24 Header files A header file is a file with extension.h which contains C function declarations and macro definitions and to be shared between several source files. There are two types of header files: the files that the programmer writes and #include<stdio.h> the files that come with your compiler. #include stack.h Including a header file = copying the content of the header file 93

25 Header files A simple practice in C programs is that we keep all the constants, macros, system wide global variables, and function prototypes in header files and include that header file wherever it is required. 94

26 95

27 Rule #1 Each module with its.h and.c file should correspond to a clear piece of functionality. Conceptually, a module is a group of declarations and functions can be developed and maintained separately from other modules, and perhaps even reused in entirely different projects. 96

28 Rule #2 The header file contains only declarations, and is included by the.c file for the module. Put only structure type declarations, function prototypes, and global variable extern declarations, in the.h file; Put the function definitions and global variable definitions and initializations in the.c file. The.c file for a module must include the.h file; the compiler can detect discrepancies between the two, and thus help ensure consistency 97

29 Rule #3 Set up program-wide functions with an extern declaration in the header file, and a defining declaration in the.c file. 98

30 Rule #4 Keep a module s internal declarations out of the header file. 99

31 Rule #5 Every header file A.h should #include every other header file that A.h requires to compile correctly, but no more. 100

32 Rule #6 The A.c file should first #include its A.h file, and then any other headers required for its code 101

33 Rule #7 Never #include a.c file for any reason! 102

34 Static based implementation 103

35 Static based implementation top D tab tab[0] tab[1] tab[2] tab[3] tab[4] C B A 104

36 Static based implementation Example tab tab[0] tab[1] tab[2] tab[3] tab[4] Push(stack,A) Push(stack,B) Push(stack,C) Push(stack,D) Pop(stack) Push(stack,E) Push(stack,F) Push(stack,G) top A B C ED F 105

37 Static based implementation This implementation of stack ADT uses an array. In the array, we add elements from left to right and we use a variable to keep track of the index of the top element. S The array storing the stack elements may become full. A push operation will then throw a full stack exception. Push an element: increment top and store the element in the array Pop: decrement top top 106

38 Stack: implementation Type_Stack.h #define N 20 typedef element; typedef struct { element data[n]; /* stack content */ int top; } stack; 107

39 Stack: implementation Stack.h #include "Type_Stack.h" extern stack CreateStack(); extern int Push(stack *p, element e); extern int Pop(stack *p); extern int Top(stack p, element *e); extern int isemptystack(stack p); extern int isfullstack(stack p); 108

40 Stack: implementation Stack.c #include "Stack.h" stack CreateStack() { } p; p.top = -1; return p; 109

41 Stack: implementation Stack.c int Push(stack *p, element e) { if (isfullstack(*p)) return 0; p->data[++p->top] = e; return 1; } 110

42 Stack: implementation Stack.c int Pop(stack *p) { } if (isemptystack(*p)) return 0; p->top--; return 1; 111

43 Stack: implementation Stack.c int Top(stack p, element *e) { if (isemptystack(p)) return 0; *e = p.data[p.top]; return 1; } 112

44 Stack: implementation Stack.c int isemptystack(stack p) { return (p.top == -1); } int isfullstack(stack p) { return (p.top == N-1); } 113

45 Performance & Limitations Let n be the number of elements in the stack. Space complexity (for n push operations) Time complexity of Push() Ο 1 Time complexity of Pop() Ο 1 Time complexity of Top() Ο 1 Time complexity of IsEmptyStack() Ο 1 Time complexity of IsFullStack() Ο 1 The maximum size of the stack must be defined in prior and cannot be changed. Trying to push a new element into a full stack causes an implementationspecific exception. Ο 114

46 Exercise Give the content of the stack after each line of code. Give also the content of x and y, and the top of the stack. #define StackMax 5 float x; float y; stack s; int i, j; s=create_stack(); Push(&s,3.2); Push(&s,2.0); stack x y top Random

47 Exercise Top(s,&x); Pop(&s); Top(s,&y); Pop(&s); Push(&s,y-x); Push(&s,7.9); Push(&s,5.7); stack x y top

48 Exercise Top(s,&x); Pop(&s); Top(s,&y); Pop(&s); Push(&s,y+x); stack x y top

49 Exercise Top(s,&x); Pop(&s); Top(s,&y); Pop(&s); y*=x; stack x y top x

50 Exercise Push(&s,1.0); Push(&s,2.0); Push(&s,3.0); Push(&s,4.0); i=2; while(i>0) { Pop(&s); i--; } Top(s,&x); stack x y top

51 Exercise Push(&s,3.0); Push(&s,4.0); i=3; j=1; while(i>0) { i--; j--; if(j==0) 4.0 Top(s,&y); 3.0 Pop(&s); } 2.0 Top(s,&x); 1.0 stack x y top

52 Exercise Push(&s,3.0); Push(&s,4.0); while(top(s,&y)) { Pop(&s); if(top(s,&x)) { Pop(&s); Push(&s,x+y); } else break; } Push(&s,y); stack x y top

53 Dynamic based implementation 122

54 Cells t[0] t[1] t[2] t[3] t[4] t[5] t[6] t[7] t[8] struct cell { element data; struct cell *next; }

55 Dynamic based implementation Implementing stacks using linked lists Push operation is implemented by inserting element at the beginning of the list. Pop operation is implemented by deleting the node from the beginning. 124

56 Stack: implementation Type_Stack.h typedef element; typedef struct cell { element data; struct cell *next; } *stack; D temp CB Push A Push B Pop Push C Push D A NULL stack 125

57 Stack: implementation Stack.h #include "Type_Stack.h" extern stack CreateStack(); extern int Push(stack *p, element e); extern int Pop(stack *p); extern int Top(stack p, element *e); extern int isemptystack(stack p); extern int isfullstack(stack p); 126

58 Stack: implementation Stack.c #include "Stack.h" stack CreateStack() { return NULL; } 127

59 Stack: implementation Stack.c int Push(stack *p, element e) { stack temp; temp = (stack) malloc(sizeof(struct cell)); if(!temp) return 0; temp->data=e; } temp->next=*p; *p=temp; return 1; 128

60 Stack: implementation Stack.c int Pop(stack *p) { stack temp; if (isemptystack(*p)) return 0; temp =*p; *p = (*p)->next; } free(temp); return 1; 129

61 Stack: implementation Stack.c int Top(stack p, element *e) { if (isemptystack(p)) return 0; *e = p->data; return 1; } 130

62 Stack: implementation Stack.c int isemptystack(stack p) { return (p == NULL); } 131

63 Performance Let n be the number of elements in the stack. Space complexity (for n push operations) Ο Time complexity of Push() Ο 1 Time complexity of Pop() Ο 1 Time complexity of Top() Ο 1 Time complexity of IsEmptyStack() Ο 1 132

64 Comparing static and dynamic implementations Static implementation Operations take constant time. Any sequence of n operations (starting from empty stack) takes time proportional to n. Dynamic implementation Grows and shrinks gracefully. Every operation takes constant time Ο 1. Every operation uses extra space and time to deal with references. 133

65 Exercise Write a program in C showing how stacks can be used for checking balancing of symbols. Examples: Example Valid? Description (A+B)+(C-D) Yes The expression is having balanced symbols ((A+B)+(C-D) No One closing parenthesis is missing ((A+B)+[C-D]) Yes Opening and immediate closing braces correspond ((A+B)+[C-D]} No The last closing brace does not correspond with the first opening parenthesis 134

66 Exercise top ()(()[()]) 135

67 Exercise Algorithm: 1. Create a stack 2. While (end of input is not reached) { 1. If the character read is not a symbol to be balanced, ignore it. 2. If the character is an opening symbol like (, {, [, push it onto the stack. 3. If it is a closing symbol like ), }, ], then if the stack is empty, report an error. Otherwise, get the top element of the stack. 4. If the symbol popped is not the corresponding opening symbol, report an error 3. At the end of input, if the stack is not empty, report an error. 136

68 Solution 137

69 138

70 Solution 139

Overview of today s lecture. Quick recap of previous C lectures. Introduction to C programming, lecture 2. Abstract data type - Stack example

Overview of today s lecture. Quick recap of previous C lectures. Introduction to C programming, lecture 2. Abstract data type - Stack example Overview of today s lecture Introduction to C programming, lecture 2 -Dynamic data structures in C Quick recap of previous C lectures Abstract data type - Stack example Make Refresher: pointers Pointers