Dictionaries CS 105. L11: Dictionaries Slide 2 Definition The Dictionary Data Structure structure that facilitates searching objects are stored with search

Dictionaries

CS 105

L11: DictionariesSlide 2

Definition

The Dictionary Data Structure structure that facilitates searching objects are stored with search keys;

insertion of an object must include a key searching requires a key and returns the

key-object pair removal also requires a key

Need an Entry interface/class Entry encapsulates the key-object pair

(just like with priority queues)


Sample Applications

An actual dictionary key: word object: word record (definition,

pronunciation, etc.) Record keeping applications

Bank account records (key: account number, object: holder and bank account info)

Student records (key: id number, object: student info)


Dictionary Interface

public interface Dictionary{ public int size(); public boolean isEmpty(); public Entry insert( int key, Object value )

throws DuplicateKeyException;public Entry find( int key );

// return null if not found public Entry remove( int key )

// return null if not found;}


Dictionary details/variations

Key types For simplicity, we assume that the keys are ints But the keys can be any kind of object as long as

they can be ordered (e.g., string and alphabetical ordering)

Duplicate entries (entries with the same key) may be allowed Our textbook calls the data structure that does

not allows duplicates a Map, while a Dictionary allows duplicates

For purposes of this discussion, we assume that dictionaries do not allow duplicates


Dictionary Implementations

Unordered list (section 8.3.1) Ordered table (section 8.3.3) Binary search tree (section 9.1)


Unordered list

Strategy: store the entries in the order that they arrive O( 1 ) insert operation

Can use an array, ArrayList, or linked list Find operation requires scanning the list

until a matching key value is found Scanning implies an O( n ) operation

Remove operation similar to find operation Entries need to be adjusted if using array/ArrayList O( n ) operation


Ordered table

Idea: if the list was ordered by key, searching is simpler/easier

Just like for priority queues, insertion is slightly more complex Need to search for proper position of

element -> O( n ) Find: don’t do a linear scan; instead,

do a binary search Note: use array/ArrayList; not a linked

list


Binary search

Take advantage of the fact that the elements are ordered

Compare the target key with middle element to reduce the search space in half

Repeat the process until the element is found or search space reduces to 1

Arithmetic on array indexes facilitate easy computation of middle position Middle of S[low] and S[high] is S[(low+high)/2] Not possible with linked lists


Binary Search Algorithm

Algorithm BinarySearch( S, k, low, high )

if low > high then return null; // not foundelse mid (low+high)/2 e S[mid]; if k = e.getKey() then return e; else if k < e.getKey() then return BinarySearch( S, k, low, mid-1 ) else return BinarySearch( S, k, mid+1, high )

array of Entries target key

BinarySearch( S, someKey, 0, size-1 );



42 5 7 8 9 12 14 17 19 22 25 27 28 33 37

low mid high

find(22)

mid = (low+high)/2



42 5 7 8 9 12 14 17 19 22 25 27 28 33 37

highlow mid

find(22)

mid = (low+high)/2


low


42 5 7 8 9 12 14 17 19 22 25 27 28 33 37

midhigh

find(22)

mid = (low+high)/2


low=mid=high


42 5 7 8 9 12 14 17 19 22 25 27 28 33 37

find(22)

mid = (low+high)/2


Time complexity of binary search

Search space reduces by half until it becomes 1

n -> n/2 -> n/4 -> … -> 1 log n steps

Find operation using binary search isO( log n )


Time complexity

O( log n )

O( n )

find()

O(n )O( n )Ordered Table

O( n )O( 1 )Unsorted List

remove()

insert()

Operation


Binary Search Tree (BST)

Strategy: store entries as nodes in a tree such that an inorder traversal of the entries would list them in increasing order

Search, remove, and insert are allO( log n ) operations All operations require a search that

mimics binary search: go to left or right subtree depending on target key value


Traversing a BST Insert, remove, and find operations all

require a key First step involves checking for a matching

key in the tree Start with the root, go to left or right child

depending on key value Repeat the process until key is found or a null

child is encountered (not found) For insert operation, duplicate key error occurs if

key already exists Operation is proportional to height of tree

( usually O(log n ) )


Insertion in BST (insert 78)44

17 88

32

28

65 97

8254

7629

80

44

88

65

82

76

80


78

Insertion in BST44

17 88

32

28

65 97

8254

7629

80

44

88

65

82

76

80


78

Removal from BST (Ex. 1)44

17 88

32

28

65 97

8254

7629

80

w

z

Remove 32


78


17 88

32

28

65 97

8254

7629

80

44

17

32

w

z


28

29

78


17 88

65 97

8254

76

80

44

17


78


17 88

32

28

65 97

8254

7629

80

wRemove

65


78


17 88

32

28

65 97

8254

7629

80

44

88

65

82

76

80

w

y

x

54



17 88

32

28

65 97

8254

29

44

88

65

82

w

54

78

8080

76


Time complexity for BSTs

O( log n ) operations not guaranteed since resulting tree is not necessarily “balanced”

If tree is excessively skewed, operations would be O( n ) since the structure degenerates to a list

Tree could be periodically reordered to prevent skewedness


Time complexity (average case)

O(n )O( log n )

O( n )Ordered Table

O( log n )

O( n )

find()

O( log n )

O( log n )

BST


remove()

insert()Operation


Time complexity (worst case)

O(n )O( log n )

O( n )Ordered Table

O( n )

O( n )

find()

O( n )O( n )BST


remove()

insert()Operation


About BSTs

AVL tree: BST that “self-balances” Ensures that after every operation, the

difference between the left subtree height and the right subtree height is at most 1

O( log n ) operation is guaranteed Many efficient searching methods are

variants of binary search trees Database indexes are B-trees (number of

children > 2, but the same principles apply)

Documents

Dictionaries CS 105. L11: Dictionaries Slide 2 Definition The Dictionary Data Structure structure that facilitates searching objects are stored with search