Tables
Symbol Symbol Tables
Symbol table, dictionary.
n
Set of items with keys. INSERT a new item. SEARCH for an existing item with a given key.
n
n
Applications.
These lecture slides have been adapted from:
n
Online phone book looks up names and telephone numbers. Spell checker looks up words in dictionary. Compiler looks up variable names to find type and memory address. Internet domain server looks up IP addresses. Web counter counts hits on web pages. "Associative memory." Index of any kind.
n
Algorithms in C, 3rd Edition, Robert Sedgewick.
n
n
n
n
n
2
Abstract Data Types
Interface. Description of data type, basic ops. Client. Program using ops defined in interface. Implementation. Actual code implementing ops.
Key and Item Operations
Full set of Key operations.
n
Create. Destroy. Compare.
generic ops for DT ops that characterize Key
n
n
typedef int Key; typedef struct { Key ID; char name[30]; } Item;
Item A
Item B
Full set of Item operations.
n
Create. Destroy. Display. Extract key. ops that characterize Item generic ops for DT
n
n
Client 1
ST
Client 2
n
Key = student ID Item = ID + Name
algorithms
3
4
Key and Item Operations
Full set of Key operations.
n
Sample Item Interface
Item with a Key. item.h typedef char *Key; // a string
Create. Destroy. Compare.
generic ops for DT ops that characterize Key
n
n
typedef char *Key; typedef struct item *Item; struct item { Key url; int count; }; Key = URL Item = URL + Count typedef struct item *Item; struct item { Key url; // name of web page int count; // number of hits }; int eq(Key, Key); int less(Key, Key); int KEYscan(Key *); Key Item void void
5
Full set of Item operations.
n
Create. Destroy. Display. Extract key. ops that characterize Item ops that specialized client might use generic ops for DT
n
n
// are keys equal? // is 1st key smaller than 2nd? // read in a Key from stdin // // // // extract key from item init an Item print item to stdout increment number of hits
6
n
n
Hit.
ITEMkey(Item); ITEMinit(Key); ITEMshow(Item); ITEMhit(Item);
Sample Item Implementation
Item with a Key. item.c (Key functions) #include <stdio.h> #include <stdlib.h> #include "item.h" #define MAXLEN 1000 char buffer[MAXLEN + 1]; int eq (Key k1, Key k2) { return strcmp(k1, k2) == 0; } int less(Key k1, Key k2) { return strcmp(k1, k2) < 0; } int KEYscan(Key *pk) { int val = scanf("%1000s", buffer); *pk = malloc(strlen(buffer) + 1); strcpy(*pk, buffer); return val; }
7
Sample Item Implementation
Item with a Key. item.c (Item functions) Key ITEMkey(Item a) { return a->url; } void ITEMshow(Item a){ printf("%s %d\n", a->url, a->count); } Item ITEMinit(Key k) { Item a = malloc(sizeof *a); a->count = 0; a->url = k; return a; } void ITEMhit(Item a) { a->count++; }
8
Symbol Table Operations
Set of Items with keys.
Symbol Table: Unsorted Array Implementation
Maintain array of Items in arbitrary order. INSERT: Add item at end of array.
Full set of operations.
n
Create. Destroy. Insert. Search. Count. Delete. Join. Sort.
generic ops for ADT
n
n
n
ops that characterize symbol table
n
n
n
other ops that many clients need
Item item; Key k; STinit(); while(KEYscan(&k) == 1) { item = STsearch(k); if (item == NULL) { item = ITEMinit(k); STinsert(item); } ITEMhit(item); ITEMshow(item); } ST client that counts URL occurrences from input stream
9
55 32 47 55 32 47
6 6
4 4
82 26 56 20 14 58 82 26 56 20 14 58 28
Key = Item = int
SEQUENTIAL SEARCH: Iterate through all elements of array. 4 6 14 20 26 82 32 47 55 56 58 28
n
n
Find kth largest.
10
Symbol Table: Unsorted Array Implementation
Symbol Table: Sorted Array Implementation
Maintain array of Items sorted by Key.
STunsortedarray.c #define MAXSIZE 10000 static Item st[MAXSIZE]; static int N = 0; // max # items // array of items // number of elements
BINARY SEARCH:
n
Examine the middle Key. If it matches, then we're done. Otherwise, search either the left or right half.
n
n
Item STinsert(Item item) { st[N++] = item; } Item STsearch(Key k) { int i; for (i = 0; i < N; i++) if eq(k, ITEMkey(st[i])) return st[i]; return NULL; } INSERT: Find insertion point and shift items right. 4 // found // not found 4 6 6 14 20 26 32 47 55 56 58 82 14 20 26 28 32 47 55 56 58 82
Key = Item = int
11
12
Symbol Table: Sorted Array Implementation
STsortedarray.c (Sedgewick 12.6) #define MAXSIZE 10000 static Item st[MAXSIZE]; static int N = 0; static Item search(int lo, int hi, Key k) { int m = (lo + hi) / 2; if (lo > hi) // not found return NULL; else if eq(k, ITEMkey(st[m])) // found return st[m]; else if less(k, ITEMkey(st[m])) // go left return search(lo, m-1, k); else // go right return search(m+1, hi, k); } Item STsearch(Key k) { return search(0, N-1, k); }
Binary Search Analysis
How many comparisons to find a name in database of size N?
n
Divide list in half each time. 625 312 156 78 39 18 9 4 2 1 62510 = 10011100012
n
n
Theorem. Binary search takes O(log N) steps. Proof. Worst-case number of steps satisfies: C(N) = 1 + C(N/2) (integer division) C(1) = 0 C(N) = log2 (N+1) Same recurrence as # bits in binary representation of N.
n n n
13
14
Symbol Table: Implementations Cost Summary
Binary Search Tree
Binary search tree: binary tree in symmetric order.
Worst Case Implementation Unsorted array Sorted array Search N log N Insert 1 N Delete 1 N
Average Case Search N/2 log N Insert 1 N/2 Delete * 1 N/2 Binary tree is either:
n
51
14
72
Empty (NULL node). An Item and two binary trees.
25 33 53 97
n
* assumes we know location of node to be deleted
43
64
84
99
Can we achieve log N performance for all ops? Symmetric order:
n
node x subtrees
Keys in nodes. No smaller than left subtree. No larger than right subtree.
n
A
smaller
B
larger
16
n
15
Binary Search Tree in C
BST is a link. LINK is a pointer to a node. NODE is comprised of three fields:
n
Tree Shape
Tree shape.
n
Many BSTs correspond to same input data. Have different tree shapes. Performance depends on shape.
n
Item with a key. Left link (BST with keys). smaller Right link (BST with larger keys). 51 STbst.c root
n
n
n
25
typedef struct STnode* link; struct STnode { Item item; item link l; l r link r; }; static link root; 12
51
14
72
14
68
14
72
43
97
33
53
97
33
53
84
99
54
79
25
17
43
64
84
99
51
64
18
BST Search
Search for Key k.
n
BST Insert
Insert Item item.
n
Code follows from BST definition. STbst.c (Sedgewick 12.7) Item search(link x, Key k) { if (x == NULL) // not found return NULL; if (eq(k, ITEMkey(x->item)) return x->item; // found
Search, then insert. Simple (but tricky) recursive code.
n
STbst.c (Sedgewick 12.7) link insert(link x, Item item) { if (x == NULL) return NEWnode(item, NULL, NULL);
// insert here
if (less(ITEMkey(item), ITEMkey(x->item)) // go left x->l = insert(x->l, item); else x->r = insert(x->r, item); return x; // go right
if (less(k, ITEMkey(x->item)) // go left return search(x->l, k); return search(x->r, k); } Item STsearch(Key k) { return search(root, k); }
19
// go right } void STinsert(Item item) { root = insert(root, item); }
20
BST Construction
Insert the following keys into BST: A S E R C H I N G X M P L
BST Analysis
Cost of search and insert BST.
n
Proportional to depth of node. 1-1 correspondence between BST and quicksort partitioning. Height of node corresponds to number of function calls on stack when node is partitioned.
n
n
Theorem. If keys are inserted in random order, then height of tree is Q(log N), except with exponentially small probability. Thus, search and insert take O(log N) time. Problem. Worst-case search and insert are proportional to N.
n
If nodes in order, tree degenerates to linked list.
21
22
Symbol Table: Implementations Cost Summary
Other Symbol Table Operations
SORT: traverse tree in inorder.
Worst Case Implementation Unsorted array Sorted array BST Search N log N N Insert 1 N N Delete 1 N N
Average Case Search N/2 log N log N Insert 1 N/2 log N Delete * 1 N/2 ???
n
Same cost as quicksort, but pay space for extra links.
FIND KTH: generalized priority queue that finds kth smallest.
n
Special case: find min, find max. Add subtree size to each node. Takes time proportional to height of tree.
M
n
n
RANGE SEARCH.
* assumes we know location of node to be deleted if delete allowed, insert/search become sqrt(N) probabilistic guarantee
E
10
T
BST: log N insert and search IF keys arrive in RANDOM order. Ahead: Can we make all ops log N if keys arrive in ARBITRARY order?
23
typedef struct node { link l, r; Item item; int N; }
4
B H P
5
W
1
F
2 1
2
V
2
Y
1
1
24
Other Symbol Table Operations: Delete
To delete at node:
n
Symbol Table: Implementations Cost Summary
At the bottom With one child With two children
just remove it. pass the child up.
AELPX AACGIM SEHN Implementation Unsorted array Sorted array BST Search N log N N
Worst Case Insert 1 N N Delete 1 N N
Average Case Search N/2 log N log N Insert 1 N/2 log N Delete * 1 N/2 sqrt(N)
n
n
find the next largest node using right-left* or left-right* swap remove as above since it now has zero or one children
* assumes we know location of node to be deleted if delete allowed, insert/search become sqrt(N)
Problem: strategy clumsy, not symmetric. Serious problem: trees not random (!!)
25
Ahead: Can we achieve log N delete? Ahead: Can we achieve log N worst-case?
26
Right Rotate, Left Rotate
Fundamental operation to rearrange nodes in a tree.
n
Right Rotate, Left Rotate
Fundamental operation to rearrange nodes in a tree.
n
Maintains BST order. Local transformations, change just 3 pointers.
Easier done than said.
n
root
x y y
link rotL(link x) { link...