Symbol Tables. Gianpiero Cabodi and Paolo Camurati Dip. Automatica e Informatica Politecnico di Torino

Transcription

1 Symbol Tables Gianpiero Cabodi and Paolo Camurati Dip. Automatica e Informatica Politecnico di Torino

2 Symbol Tables Definition: A Symbol Table is a data structure with records including a key basic and allowing operations such as: Insertion of a new record Search of a record with a given key. Sometimes symbol tables are denoted with the term dictionary. A.Y. 2016/17 08 Symbol Tables 2

3 Applications of Symbol Tables Applications Target, i.e., searching Key Return Value Dictionary Definition Word Definition Book index Relevant pages Word Page list DNS IP address given its URL URL IP address Invers DNS URL given its IP address IP address URL File system File on disk File name Disk location Web search Web page Keyword Page list A.Y. 2016/17 08 Symbol Tables 3

4 Symbol Table ADT Operations: Insert a new element Search an element of a given key Delete an element of a given key Select the r-th smallest element Order the table using the key Union of two tables. A.Y. 2016/17 08 Symbol Tables 4

5 Search algorithm = implementation of the symbol table ADT. Record of type Item including keys of type Key. Operations on the Key type: key KEYget(Item); key KEYscan(); int KEYcompare(key, key); Compare 2 keys Get key from element Read key from standard input A.Y. 2016/17 08 Symbol Tables 5

6 Operations on the Item type: Item ITEMscan(); void ITEMshow(Item); int ITEMcheckvoid(Item); Item ITEMsetvoid(); void ITEMfree(Item); int ITEMless(Item, Item); int ITEMgreater(Item, Item); Read an element from standard input Print-out an element on standard output Check element emptyness Free an element Create an empty element Compare 2 elements given their keys A.Y. 2016/17 08 Symbol Tables 6

7 I Category ADT Item.h #define MAXC 3 typedef struct item *Item; typedef char *Key; Item ITEMscan(); void ITEMshow(Item data); int ITEMcheckvoid(Item data); Item ITEMsetvoid(); void ITEMfree(Item data); int ITEMless(Item data1, Item data2); int ITEMgreater(Item data1, Item data2); Key KEYget(Item data); Key KEYscan(); int KEYcompare(Key k1, Key k2); A.Y. 2016/17 08 Symbol Tables 7

8 Item.c #include <stdio.h> #include <stdlib.h> #include <string.h> #include "Item.h" Direct Access Table: letters A..Z item Other Tables: string name value struct item { char *name; int value; ; Given a letter, this function int getindex(key key) { if (key == NULL) return -1; computes the corresponding return (key[0] -'A'); integer. For direct access tables only. Item ITEMscan() { char name[maxc]; int value; Item data=(item) malloc(sizeof(struct item)); printf("name = "); scanf("%s", name); data->name = strdup(name); printf("value = "); scanf("%d", &value); data->value = value; return data; A.Y. 2016/17 08 Symbol Tables 8

9 void ITEMshow(Item data) { printf("\nname = %s", data->name); printf("\nvalue = %d \n", data->value); int ITEMcheckvoid(Item data) { Key k1, k2=""; k1 = KEYget(data); if (KEYcompare(k1,k2)==0) return 1; else return 0; Item ITEMsetvoid() { char name[maxc]=""; Item tmp = (Item) malloc(sizeof(struct item)); if (tmp!= NULL) { tmp->name = strdup(name); tmp->value = -1; return tmp; A.Y. 2016/17 08 Symbol Tables 9

10 void ITEMfree(Item data) { if (data == NULL) return; if (data->name!= NULL) free(data->name); free(data); int ITEMless (Item data1, Item data2) { Key k1 = KEYget(data1), k2 = KEYget(data2); if (KEYcompare(k1, k2) == -1) return 1; else return 0; int ITEMgreater(Item data1, Item data2) { Key k1 = KEYget(data1), k2 = KEYget(data2); if (KEYcompare(k1, k2) == 1) return 1; else return 0; A.Y. 2016/17 08 Symbol Tables 10

11 Key KEYscan() { char name[maxc]; Key k; scanf("%s", name); k = strdup(name); return k; int KEYcompare(Key k1, Key k2) { return strcmp(k1, k2); Key KEYget(Item data) { return data->name; A.Y. 2016/17 08 Symbol Tables 11

12 I Category ADT ST ST.h typedef struct symboltable *ST; ST STinit(int) ; void STfree(ST) ; int STcount(ST) ; int STinsert(ST,Item) ; int STsearch(ST,Key) ; void STdelete(ST,Key) ; Item STdisplay_item(ST, int) ; int STselect(ST,int) ; void STdisplay(ST) ; A.Y. 2016/17 08 Symbol Tables 12

13 Implementations Linear structures: Direct Access Tables Arrays: Unordered Ordered Lists: Unordered Ordered A.Y. 2016/17 08 Symbol Tables 13

14 Tree structures: Binary Search Trees (BSTs) Balanced Trees: RB-tree B-tree Hash Tables A.Y. 2016/17 08 Symbol Tables 14

15 Direct Access Tables maxn: Number of elements in the entire universe U Key k U Function getindex(k) returns an integer from 0 to maxn-1, acting as an array index Examples of getindex: If keys are capital letters in the English alphabet A..Z, getindex(k) = k- A ; If keys are integers from 0 to maxn-1, getindex(k) = k; A.Y. 2016/17 08 Symbol Tables 15

16 array st->a[maxn]: If the key k is in the table, its position st- >a[getindex(k)], otherwise st- >a[getindex(k)] stores an empty element Store a set K of K keys ( K = st->size). A.Y. 2016/17 08 Symbol Tables 16

17 A B H E G N M P O Y Q C D I Z T U V K (Used Keys) U (Keys Universe) K J X F L W S R A.Y. 2016/17 08 Symbol Tables st C D F I

18 ST.c #include <stdio.h> #include <stdlib.h> #include "Item.h" #include "ST.h" struct symboltable {Item *a; int maxn; int size;; ST STinit(int maxn) { ST st; int i; st = malloc(sizeof(*st)); st->a = malloc(maxn * sizeof(item) ); for (i = 0; i < maxn; i++) st->a[i] = ITEMsetvoid(); st->maxn = maxn; st->size = 0; return st; void STfree(ST st) { int i; for(i=0; i<st->maxn; i++) ITEMfree(st->a[i]); if (st->a!= NULL) free(st->a); free(st); A.Y. 2016/17 08 Symbol Tables 18

19 int STcount(ST st) { return st->size; int STinsert(ST st, Item data) { int index = getindex(keyget(data)); st->a[index] = data; st->size++; return index; int STsearch(ST st, Key k) { int index = getindex(k); if (ITEMcheckvoid(st->a[index])) return -1; return index; void STdelete(ST st, Key k) { st->a[getindex(k)] = ITEMsetvoid(); st->size--; A.Y. 2016/17 08 Symbol Tables 19

20 int STselect(ST st, int r) { int i; for (i = 0; i < st->maxn; i++) if ( (ITEMcheckvoid(st->a[i])==0) && (r-- == 0)) return getindex(keyget(st->a[i])); return -1; void STdisplay(ST st){ int i; for (i = 0; i < st->maxn; i++) if (ITEMcheckvoid(st->a[i])==0) ITEMshow(st->a[i]); Item STdisplay_item(ST st, int j) { return st->a[j]; A.Y. 2016/17 08 Symbol Tables 20

21 Pros & Cons Insert, search, and delete complexity: T(n) = (1) Init and select complexity: T(n) = (maxn) Memory usage: S(n) = ( U ) = (maxn) Applicable only for small maxn Memory loss for K << maxn Often used to convert keys into integers (and viceversa) with a cost equal to 1. A.Y. 2016/17 08 Symbol Tables 21

22 Unordered Array Function to compare keys Tail insertion Use realloc to resize tables during insert Search through linear visit Select has no sens, as it supposes an order Delete with a left-shift of one position for all subsequent elements. A.Y. 2016/17 08 Symbol Tables 22

23 ST.c #include <stdio.h> #include <stdlib.h> #include "Item.h" #include "ST.h" struct symboltable { Item *a; int maxn; int size;; ST STinit(int maxn) { ST st; st = malloc(sizeof(*st)); if (st == NULL) { printf("memory allocation error\n"); return NULL; st->a = malloc(maxn * sizeof(item) ); for (i = 0; i < maxn; i++) st->a[i] = NULL; st->maxn = maxn; st->size = 0; return st; A.Y. 2016/17 08 Symbol Tables 23

24 void STfree(ST st) { int i; for(i=0; i<st->size; i++) ITEMfree(st->a[i]); if (st->a!= NULL) free(st->a); free(st); int STcount(ST st) { return st->size; int STinsert(ST st, Item data) { int i = st->size; if (st->size >= st->maxn) { st->a = realloc(st->a, (2*st->maxN)*sizeof(Item)); if (st->a == NULL) return -1; st->maxn = 2*st->maxN; st->a[i] = data; st->size++; return i; A.Y. 2016/17 08 Symbol Tables 24

25 int STsearch(ST st, Key k) { int i; if (st->size == 0) return -1; for (i = 0; i < st->size; i++) if (KEYcompare(k, KEYget(st->a[i]))==0) return i; return -1; void STdelete(ST st, Key k) { int i, j=0; while (KEYcompare(KEYget(st->a[j]), k)!=0) j++; for (i = j; i < st->size-1; i++) st->a[i] = st->a[i+1]; st->size--; void STdisplay(ST st){ int i; for (i = 0; i < st->size; i++) ITEMshow(st->a[i]; A.Y. 2016/17 08 Symbol Tables 25

26 Pros & Cons Init and insert complexity: T(n) = (1) Search and delete complexity: T(n) = O(n) Memory usage S(n) = (maxn) Applicable only for small maxn Memory loss for K << maxn Often used to transform keys into integers with a cost equal to 1. The inverse operation has a linear cost. A.Y. 2016/17 08 Symbol Tables 26

27 Ordered Arrays Ordering pro & cons: Ordered insertions have a linear cost T(n) = O(n), the overall cost is quadratic for n insertions T(n) = O(n 2 ) Dicothomic searches have a logarithmic cost T(n) = O(logn) Linear searches (by stopping as soon as possible) have cost equal to T(n) = O(n) Deletes have with linear cost T(n) = O(n) Select is straighforward: Position and index do coincide. A.Y. 2016/17 08 Symbol Tables 27

28 Context Dependent Implementation: Dynamic with many insert/delete: ordered insertions (by shifting all larger elements) have a quadratic cost Static with insertions only while reading from file phase, no delete, and many searches: Insert on tail and order once with a cost equal to O(nlogn). A.Y. 2016/17 08 Symbol Tables 28

29 Dynamic Situation ST.c #include <stdio.h> #include <stdlib.h> #include "Item.h" #include "ST.h" struct symboltable { Item *a; int maxn; int size;; ST STinit(int maxn) { ST st; st = malloc(sizeof(*st)); if (st == NULL) { printf("memory allocation error\n"); return NULL; st->a = malloc(maxn * sizeof(item) ); st->maxn = maxn; st->size = 0; return st; A.Y. 2016/17 08 Symbol Tables 29

30 void STfree(ST st) { int i; for(i=0; i<st->size; i++) ITEMfree(st->a[i]); if (st->a!= NULL) free(st->a); free(st); int STcount(ST st) { return st->size; int STselect(ST st, int r) { return r; void STdelete(ST st, Key k) { int i, j = 0; while (KEYcompare(KEYget(st->a[j]), k)!=0) j++; for (i = j; i < st->size-1; i++) st->a[i] = st->a[i+1]; st->size--; A.Y. 2016/17 08 Symbol Tables 30

31 int STinsert(ST st, Item data) { int i = st->size++; if (st->size > st->maxn) { st->a = realloc(st->a, (2*st->maxN)*sizeof(Item)); if (st->a == NULL) return -1; st->maxn = 2*st->maxN; while( (i>0) && ITEMless(data, st->a[i-1]) ) { st->a[i] = st->a[i-1]; i--; st->a[i] = data; return i; void STdisplay(ST st){ int i; for (i = 0; i < st->size; i++) ITEMshow(st->a[i]); A.Y. 2016/17 08 Symbol Tables 31

32 Item STdisplay_item(ST st, int j) { return st->a[j]; int STlinsearch(ST st, Key k) { int i; if (st->size == 0) return -1; for (i = 0; i < st->size; i++) { if (KEYcompare(k, KEYget(st->a[i]))==0) return i; if (KEYcompare(k, KEYget(st->a[i]))==-1) break; return -1; A.Y. 2016/17 08 Symbol Tables 32

33 int searchr(st st, int l, int r, Key k) { int m = (l + r)/2; if (l > r) return -1; if (KEYcompare(k, KEYget(st->a[m]))==0) return m; if (l == r) return -1; if (KEYcompare(k, KEYget(st->a[m]))==-1) return searchr(st, l, m-1, k); else return searchr(st, m+1, r, k); int STbinsearch(ST st, Key k) { return searchr(st, 0, st->size-1, k) ; A.Y. 2016/17 08 Symbol Tables 33

34 Unordered Lists Head insertion Search through sequential visit (returning the element) Select has no sense, as it supposes an ordering Delete, once found the element, move only pointers Recursive search and delete. A.Y. 2016/17 08 Symbol Tables 34

35 ST.c #include <stdio.h> #include <stdlib.h> #include "Item.h" #include "ST.h" typedef struct STnode* link; struct STnode { Item data; link next; ; struct symboltable { link head; int size; link z; ; link NEW( Item data, link next) { link x = malloc(sizeof *x); x->data = data; x->next = next; return x; A.Y. 2016/17 08 Symbol Tables 35

36 ST STinit(int maxn) { ST st; st = malloc(sizeof(*st)); if(st == NULL) { printf("memory allocation error\n"); return NULL; st->size = 0; st->head = (st->z = NEW(ITEMsetvoid(), NULL)); return st; void STfree(ST st) { if (st == NULL) return; free(st->head); free(st); int STcount(ST st) { return st->size; A.Y. 2016/17 08 Symbol Tables 36

37 void STinsert(ST st, Item data) { st->head = NEW(data, st->head); st->size++; Item searchr(link t, Key k, link z) { if (t == z) return ITEMsetvoid(); if (KEYcompare(KEYget(t->data), k)==0) Wrapper return t->data; for searchr return searchr(t->next, k, z); Item STsearch(ST st,key k){ return searchr(st->head,k,st->z); void STdisplay(ST st) { link x = st->head; while (x!= st->z) { ITEMshow(x->data); x = x->next; A.Y. 2016/17 08 Symbol Tables 37

38 link deleter(link x, Key k) { if ( x == NULL ) return NULL; if (KEYcompare(KEYget(x->data), k)==0) { link t = x->next; free(x); return t; x->next = deleter(x->next, k); return x; void STdelete(ST st, Key k) { st->head = deleter(st->head, k); st->size--; A.Y. 2016/17 08 Symbol Tables 38

39 Pros & Cons Init and insert complexity: T(n) = (1) Search and delete complexity: T(n) = O(n) Memory usage: S(n) = (n) A.Y. 2016/17 08 Symbol Tables 39

40 Ordered Lists Ordered insertion Searches through sequential visits (returning an element) Selections through sequential visits would suppose an ordering Delete, once found an element, only pointers are moved Iterative insert, search, select, and delete. A.Y. 2016/17 08 Symbol Tables 40

41 ST.c #include <stdio.h> #include <stdlib.h> #include "Item.h" #include "ST.h" typedef struct STnode* link; struct STnode { Item data; link next; ; struct symboltable { link head; int size; link z; ; link NEW( Item data, link next) { link x = malloc(sizeof *x); x->data = data; x->next = next; return x; A.Y. 2016/17 08 Symbol Tables 41

42 ST STinit(int maxn) { ST st = malloc(sizeof(*st)); if(st == NULL) { printf("memory allocation error\n"); return NULL; st->size = 0; st->z = NEW(ITEMsetvoid(), NULL); st->head = NEW(ITEMsetvoid(), st->z); return st; void STfree(ST st) { if (st == NULL) return; free(st->head); free(st); int STcount(ST st) { return st->size; Lists with sentinels on the head and tail A.Y. 2016/17 08 Symbol Tables 42

43 void STinsert(ST st, Item data) { link x, t; t = malloc(sizeof(link)); t->data = data; t->next = NULL; for (x = st->head; x->next!= st->z; x = x->next) if (ITEMgreater(x->next->data, data)) break; t->next = x->next; x->next = t; st->size++; Item STsearch(ST st, Key k) { link x; for (x = st->head->next; x!= st->z; x = x->next) if (KEYcompare( KEYget(x->data), k) ==0) return x->data; return ITEMsetvoid(); A.Y. 2016/17 08 Symbol Tables 43

44 void STdelete(ST st, Key k) { link x; for (x = st->head; x->next!= st->z; x = x->next) if (KEYcompare( KEYget(x->next->data), k) ==0) x->next = x->next->next; return; Item STselect(ST st, int r) { int i; link x = st->head; for (i = r; i>=0; i--) x = x->next; return x->data; void STdisplay(ST st) { link x; for (x = st->head->next; x!= st->z; x = x->next) ITEMshow(x->data); A.Y. 2016/17 08 Symbol Tables 44

45 Pros & Cons Init complexity: T(n) = (1) Insert, search, select, and delete complexity: T(n) = O(n) Memory usage: S(n) = (n) A.Y. 2016/17 08 Symbol Tables 45

46 Complexity Worst Case Insert Search Select Direct Acc. Table 1 1 maxn Unordered A. 1 n Order. A. Linear S. n n 1 Order. A. Bin. S. N logn 1 Unordered List 1 n Ordered List n n n BST n n n RB-tree logn logn nlogn Hashing 1 n A.Y. 2016/17 08 Symbol Tables 46

47 Average Case Insert Hit Miss Direct Acc. Table Unordered A. 1 n/2 n/2 Order. A. Linear S. n/2 n/2 n/2 Order. A. Bin. S. n/2 logn logn Unordered List 1 n/2 N Ordered List n/2 n/2 n/2 BST logn logn logn RB-tree logn logn logn Hashing A.Y. 2016/17 08 Symbol Tables 47

48 References Symbol Tables Sedgewick 12.1 Direct Access Tables Cormen 12.1 Sedgewick 12.2 Ordered Tables on Arrays Sedgewick 12.3, 12.4 Unorderd Tables on Lists Sedgewick 12.3 A.Y. 2016/17 08 Symbol Tables 48