![Page 1: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/1.jpg)
2IL50 Data Structures
Fall 2015
Lecture 8: Augmenting Data Structures
![Page 2: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/2.jpg)
Binary Search Trees
![Page 3: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/3.jpg)
5
Binary search trees
root of T denoted by root[T] internal nodes have four fields:
key (and possible other satellite data)
left: points to left child
right: points to right child
p: points to parent. p[root[T]] = NIL
1
73
84
Binary tree T
root[T]
= NIL
![Page 4: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/4.jpg)
Binary search trees
a binary tree is a leaf or a root node x with a binary tree as its left and/or right child
Binary-search-tree property if y is in the left subtree of x, then key[y] ≤ key[x] if y is in the right subtree of x, then key[y] ≥ key[x]
1
5
73
84
k
≤ k ≥ k
![Page 5: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/5.jpg)
Minimizing the running time
all operations can be executed in time proportional to the height h of the tree (instead of proportional to the number n of nodes in the tree)
Worst case:
Solution: guarantee small height (balance the tree)
➨ h = Θ(log n)
Θ(n)
Balanced binary search trees
Search, Minimum, Maximum, Predecessor, Successor, Insert, and Delete can be executed in time Θ(log n).
![Page 6: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/6.jpg)
Red-black Trees
![Page 7: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/7.jpg)
Red-black treebinary search tree where each node has a color attribute which is either red or black
Red-black properties
1. Every node is either red or black.
2. The root is black
3. Every leaf (nil[T]) is black.
4. If a node is red, then both its children are black.(Hence no two reds in a row on a simple path from the root to a leaf)
5. For each node, all paths from the node to descendant leaves contain the same number of black nodes.
10
5012
17
182
Red-black trees
LemmaA red-black tree with n nodes has height ≤ 2 log(n+1).
![Page 8: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/8.jpg)
15
15
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
Step1 find the leaf where the node
should be inserted replace the leaf by a red node
that contains the key to be inserted
10
5012
17
232
![Page 9: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/9.jpg)
15
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
Red-black properties
3. Every node is either red or black.
4. The root is black
5. Every leaf (nil[T]) is black.
6. If a node is red, then both its children are black.
7. For each node, all paths from the node to descendant leaves contain the same number of black nodes.
10
5012
17
232
The new node is red ➨ Property 2 or 4 can be violated.
Remove the violation by rotations and recoloring.
![Page 10: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/10.jpg)
Rotation
y
x
x
y
right rotation around y
left rotation around x
![Page 11: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/11.jpg)
while z ≠ root[T] and color[p[z]] = red
do if p[z] == left[p[p[z]]]
then
else “symmetric case”
y = right[p[p[z]]]
case i: y is red
color p[z] and y black, color p[p[z]] red z = p[p[z]] continue up the tree
Step 2: Fixing the red-black properties
Invariant: z and p[z] are both red and this is the only red-black violation (or z is a red root ➨ just recolor and terminate)
hence p[z] ≠ root[T]
z
p[z]
p[p[z]]
y
z
![Page 12: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/12.jpg)
right rotation
around b
+ recolor
left rotation
around a
Step 2: Fixing the red-black properties
Invariant: z and p[z] are both red and this is the only red-black violation (or z is a red root ➨ just recolor and terminate)
case ii and iii: y is black
z
a
b
y
a
z
b
y b
z
y
a
case ii: z == right[p[z]] case iii: z == left[p[z]] ✔
![Page 13: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/13.jpg)
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
15
10
5012
17
232
case ii (symmetric version)
left rotation
around 12
+ recolor
right rotation
around 1717
10
5012
15
232
12
10
5015
17
232
case iii (symmetric version)
✔
![Page 14: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/14.jpg)
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
move up the tree as long as case i occurs and recolor accordingly
as soon as case ii or iii occurs ➨ at most two rotations and two recolorings ➨✔
if you reach the root or the parent of z is black ➨✔
Running time? O(height of the tree) = O(log n)
![Page 15: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/15.jpg)
Red-black trees: Deletion
1. Do a regular binary search tree deletion
2. Fix the red-black properties
Slightly more complicated case distinction than insertionsee book for details
can be done by recoloring as before and at most three rotations
➨ Search, insert, and delete can be executed with a red-black tree in O(log n) time.
![Page 16: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/16.jpg)
Augmenting Data Structures
![Page 17: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/17.jpg)
Data structures
Data structures are used in many applications
directly: the user repeatedly queries the data structure indirectly: to make algorithms run faster
In most cases a standard data structure is sufficient (possibly provided by a software library)
But sometimes one needs additional operations that aren’t supported by any standard data structure
➨ need to design new data structure?
Not always: often augmenting an existing structure is sufficient
![Page 18: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/18.jpg)
Example
S set of elements, each with an unique key.
Operations
Search(S, k): return a pointer to an element x in S with key[x] = k, or NIL if such an element does not exist.
OS-select(S, i): return a pointer to an element x in S with the ith smallest key (the key with rank i)
Solution: sorted array
2 5 6 9 10 11 24 27 31 35 41 43 54 55 73A
the key with rank i is stored in A[i]
![Page 19: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/19.jpg)
Example
S set of elements, each with an unique key.
Operations
Search(S, k): return a pointer to an element x in S with key[x] = k, or NIL if such an element does not exist.
OS-select(S, i): return a pointer to an element x in S with the ith smallest key (the key with rank i)
Insert(S, x): inserts element x into S, that is, S ← S ⋃ {x}
Delete(S, x): remove element x from S
Solution?
![Page 20: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/20.jpg)
OS-select(S, 3): report key with rank 3
Idea 1: store the rank of each node in the node
Idea: Use red-black trees
NIL NIL
2
NIL NIL
NIL
5012
17
18
NIL NIL
10 Is the key with rank 3 in the left subtree, in the right subtree, or in the root?
2 2 │ 1➨
![Page 21: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/21.jpg)
Problem:
Idea 1: Store the rank in each node
NIL NIL
2
NIL NIL
NIL
5012
17
18
NIL NIL
10
50 │ 6
10 │ 2
2 │ 1
12 │ 3
17 │ 4
18 │ 5
Insertion can change the rank of every node!
➨ worst case O(n)
![Page 22: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/22.jpg)
Problem:
Idea 2: store the size of the subtree in each node
Idea 1: Store the rank in each node
NIL NIL
2
NIL NIL
NIL
5012
17
18
NIL NIL
10
50 │ 6
10 │ 2
2 │ 1
12 │ 3
17 │ 4
18 │ 5
Insertion can change the rank of every node!
➨ worst case O(n)
![Page 23: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/23.jpg)
Idea 2: Store the size of the subtree
NIL NIL
2
NIL NIL
NIL
5012
17
18
NIL NIL
10
50 │ 1
10 │ 6
2 │ 1
12 │ 2
17 │ 1
18 │ 4
![Page 24: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/24.jpg)
store in each node x: left [x], right [x] parent [x] key [x] color [x]
size [x] = number of keys in subtree rooted at x
(size [NIL] = 0)
Idea 2: Store the size of the subtree
NIL NIL
2
NIL NIL
NIL
5012
17
18
NIL NIL
10
50 │ 1
10 │ 6
2 │ 1
12 │ 2
17 │ 1
18 │ 4
order-statistic tree
![Page 25: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/25.jpg)
OS-Select(x, i): return pointer to node containing the ith smallest key of the subtree rooted at x
OS-Select(x , i)
1. r = size[left[x]] + 1
2. if i == r
3. then return x
4. else if i < r
5. then return OS-Select(left[x], i)
6. else return OS-Select(right[x], i)
Running time?
Order-statistic trees: OS-Select
OS-Select(x, 17)
x
size = 16
r = 17
size = 15size = 24
r = 25r = 16
i-r O(log n)
![Page 26: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/26.jpg)
Order-statistic trees: OS-Rank
OS-Rank(T, x): return the rank of x in the linear order determined by an inorder walk of T
= 1 + number of keys smaller than x
x
![Page 27: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/27.jpg)
Order-statistic trees: OS-Rank
OS-Rank(T, x): return the rank of x in the linear order determined by an inorder walk of T
= 1 + number of keys smaller than x
OS-Rank(T, x)
1. r = size[left[x]] + 1
2. y = x
3. while y ≠ root [T]
4. do if y == right[p[y]]
5. then r = r + size[left[p[y]]] + 1
6. y = p[y]
7. return r
x
Running time? O(log n)
![Page 28: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/28.jpg)
OS-Rank: CorrectnessOS-Rank(T, x)
1. r = size[left[x]] + 12. y = x3. while y ≠ root [T]4. do if y == right[p[y]]5. then r = r + size [left[p[y]] + 16. y = p[y]7. return r
InvariantAt the start of each iteration of the while loop, r = rank of key[x] in Ty
Initialization
r = rank of key[x] in Tx (y = x) = number of keys smaller than key[x] in Tx +1
= size[left[x]] + 1 (binary-search-tree property)
subtree with root y
![Page 29: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/29.jpg)
OS-Rank: CorrectnessOS-Rank(T, x)
1. r = size[left[x]] + 12. y = x3. while y ≠ root [T]4. do if y == right[p[y]]5. then r = r + size [left[p[y]] + 16. y = p[y]7. return r
InvariantAt the start of each iteration of the while loop, r = rank of key[x] in Ty
Termination
loop terminates when y = root[T] ➨ subtree rooted at y is entire tree ➨ r = rank of key[x] in entire tree
![Page 30: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/30.jpg)
OS-Rank: CorrectnessOS-Rank(T, x)
1. r = size[left[x]] + 12. y = x3. while y ≠ root [T]4. do if y == right[p[y]]5. then r = r + size [left[p[y]] + 16. y = p[y]7. return r
InvariantAt the start of each iteration of the while loop, r = rank of key[x] in Ty
Maintenance
case i: y = right[p[y]]
➨ all keys Tleft[p[y]] and key[p[y]] smaller than key[x]
➨ rank key[x] in Tp[y] = rank key[x] in Ty + size [left[p[y]] + 1
![Page 31: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/31.jpg)
OS-Rank: CorrectnessOS-Rank(T, x)
1. r = size[left[x]] + 12. y = x3. while y ≠ root [T]4. do if y == right[p[y]]5. then r = r + size [left[p[y]] + 16. y = p[y]7. return r
InvariantAt the start of each iteration of the while loop, r = rank of key[x] in Ty
Maintenance
case ii: y = left[p[y]]
➨ all keys Tright[p[y]] and key[p[y]] larger than key[x]
➨ rank key[x] in Tp[y] = rank key[x] in Ty
![Page 32: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/32.jpg)
Order-statistic trees: Insertion and deletion
Insertion and deletionas in a regular red-black tree, but we have to update size[x] field
![Page 33: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/33.jpg)
15
15
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
Step1 find the leaf where the node
should be inserted replace the leaf by a red node
that contains the key to be inserted
size of the new node = 1 increment size of each node on the
search path
10
5012
17
232
size[x] = 1
+1
+1
+1
+1
![Page 34: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/34.jpg)
15
Red-black trees: Insertion
1. Do a regular binary search tree insertion
2. Fix the red-black properties
Red-black properties
3. Every node is either red or black.
4. The root is black
5. Every leaf (nil[T]) is black.
6. If a node is red, then both its children are black.
7. For each node, all paths from the node to descendant leaves contain the same number of black nodes.
10
5012
17
232
The new node is red ➨ Property 2 or 4 can be violated.
Remove the violation by rotations and recoloring.
![Page 35: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/35.jpg)
Rotation
y
x
x
y
right rotation around y
left rotation around x
A rotation affects only size[x] and size[y]
We can determine the new values based on the size of children:
size[x] = size[left[x]] + size[right[x]] + 1
and the same for y …
![Page 36: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/36.jpg)
Order-statistic trees
The operations Insert, Delete, Search, OS-Select, and OS-Rank can be executed with an order-statistic tree in O(log n) time.
![Page 37: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/37.jpg)
Augmenting data structures
Methodology for augmenting a data structure
1. Choose an underlying data structure.
2. Determine additional information to maintain.
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations.
You don’t need to do these steps in strict order!
Red-black trees are very well suited to augmentation …
OS tree
1. R-B tree
2. size[x]
3. maintain size during insert and delete
4. OS-Select and OS-Rank
![Page 38: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/38.jpg)
Augmenting red-black trees
TheoremAugment a R-B tree with field f, where f[x] depends only on information in x, left[x], and right[x] (including f[left[x]] and f[right[x]]). Then can maintain values of f in all nodes during insert and delete without affecting O(log n) performance.
When we alter information in x, changes propagate only upward on the search path for x …
![Page 39: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/39.jpg)
Augmenting red-black trees
TheoremAugment a R-B tree with field f, where f[x] depends only on information in x, left[x], and right[x] (including f[left[x]] and f[right[x]]). Then can maintain values of f in all nodes during insert and delete without affecting O(log n) performance.
Proof (insert)
Step 1 Do a regular binary search tree insertion
x
go up from inserted node and update f additional time: O(log n)
![Page 40: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/40.jpg)
Augmenting red-black trees
TheoremAugment a R-B tree with field f, where f[x] depends only on information in x, left[x], and right[x] (including f[left[x]] and f[right[x]]). Then can maintain values of f in all nodes during insert and delete without affecting O(log n) performance.
Proof (insert)
Step 2 Fix the red-black properties by rotations and recoloring
update f for x, y, and their ancestors additional time per rotation: O(log n)
xxy
y
![Page 41: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/41.jpg)
Example: Interval trees
![Page 42: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/42.jpg)
Interval trees
S set of closed intervals
Operations
Interval-Insert(T, x): adds an interval x, whose int field is assumed to contain an interval, to the interval tree T.
Interval-Delete(T, x): removes the element x from the interval tree T.
Interval-Search(T, j): returns pointer to a node x in T such that int[x] overlaps j, or nil[T] if no such element exists.
closed: endpoints are part of the interval
low[i] high[i]
ij
![Page 43: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/43.jpg)
Methodology
1. Choose an underlying data structure.
2. Determine additional information to maintain.
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations.
![Page 44: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/44.jpg)
Methodology
1. Choose an underlying data structure.
use red-black trees each node x contains interval int[x] key is left endpoint low[int[x]]
inorder walk would list intervals sorted by low endpoint
2. Determine additional information to maintain.
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations.
![Page 45: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/45.jpg)
Methodology
1. Choose an underlying data structure. ✔
2. Determine additional information to maintain.
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations.
![Page 46: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/46.jpg)
Additional information for Interval-Search
j
low[.] ≤ low[i] low[.] > low[i]
i
i
j case 1: i ∩ j ≠ Ø➨ report i
![Page 47: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/47.jpg)
Additional information for Interval-Search
case 1: i ∩ j ≠ Ø
case 2: j lies left of i
➨ j cannot overlap any interval in the right
subtree
j
low[.] ≤ low[i] low[.] > low[i]
i
i
j ➨ report i
![Page 48: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/48.jpg)
Additional information for Interval-Search
case 1: i ∩ j ≠ Ø
case 2: j lies left of i
➨ j cannot overlap any interval in the right
subtree
case 3: j lies right of i
➨ need additional information!j
low[.] ≤ low[i] low[.] > low[i]
i
i
j ➨ report i
max[x] = max endpoint value in subtree rooted at x= max{high[i] where i is stored in the subtree rooted at x}
![Page 49: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/49.jpg)
Additional information for Interval-Search
case 1: i ∩ j ≠ Ø
case 2: j lies left of i
➨ j cannot overlap any interval in the right
subtree
case 3: j lies right of i
➨ j overlaps interval in left subtree if and only if low[j] ≤ max[left[i]]j
low[.] ≤ low[i] low[.] > low[i]
i
i
j ➨ report i
max[x] = max endpoint value in subtree rooted at x= max{high[i] where i is stored in the subtree rooted at x}
![Page 50: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/50.jpg)
Methodology
1. Choose an underlying data structure. ✔
2. Determine additional information to maintain. ✔
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations.
![Page 51: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/51.jpg)
Interval-Search
Interval-Search(T, j)
1. x = root [ T ]
2. while x ≠ nil[T] and j does not overlap int[x]
3. do if left[x] ≠ NIL and max[left[x]] ≥ low[j]
4. then x = left[x]
5. else x = right[x]
6. return x
Correctness
InvariantIf tree T contains an interval that overlaps j, then there is
such an interval in the subtree rooted at x.
Running time? O(log n)
![Page 52: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/52.jpg)
Methodology
1. Choose an underlying data structure. ✔
2. Determine additional information to maintain. ✔
3. Verify that we can maintain additional information for existing data structure operations.
4. Develop new operations. ✔
![Page 53: 2IL50 Data Structures Fall 2015 Lecture 8: Augmenting Data Structures](https://reader035.vdocuments.net/reader035/viewer/2022062314/56649f155503460f94c2a56d/html5/thumbnails/53.jpg)
Maintain additional informationTheorem
Augment a R-B tree with field f, where f[x] depends only on information in x, left[x], and right[x] (including f[left[x]] and f[right[x]]). Then can maintain values of f in all nodes during insert and delete without affecting O(log n) performance.
Additional informationmax[x] = max endpoint value in subtree rooted at x
max[x] depends only on
information in x: high[int[x]] information in left[x]: max[left[x]] information in right[x]: max[right[x]] max[x] = max{high[int[x]], max[left[x]], max[right[x]]}
➨ insert and delete still run in O(log n) time