- Lookup Algorithm:
Record lookup( x ) { n = root node; // Start at the root /* ======================================== Traverse internal nodes to reach a leaf ======================================== */ while ( n ≠ leaf node ) { n is indexed using component i; if ( x.compi < n.key ) n = n.left; else n = n.right; } /* ============================ We have reached a leaf node ============================ */ if ( x is found in n (leaf node) ) { return Record for x } else { return No Found; } }Example: lookup age = 35 and salary = 500K
- Insert Algorithm for the
kd-tree:
insert ( Record x ) { Use the search key in x to find: the leaf node L that will hold x if ( L has space ) { insert record x in (block) L; } else { Choose a component key value K that: divides L into 2 halves: L1 and L2; Move all records with key < K into L1; Move all records with key >= K into L2; Replace L by an internal node with key K; K,left = L1; K.right = L2; } }
- Example:
- Insert the record
for a person with
age = 35 and
salary = 500K into the
following
kd-tree:
- Search for the leaf node
that holds age = 35,
salary = 500K:
- This level must use
age to
make a branch decision.
Therefore:
- Find a age value that
can be used to
divide the
records:
25 400 45 350 35 500into 2 halves
- Use the median = 35
Result:
- Find a age value that
can be used to
divide the
records:
- Insert the record
for a person with
age = 35 and
salary = 500K into the
following
kd-tree:
- Delete
- The delete operation is
very complex
and require
many block accesses
(If you have studies the delete algorithm in Binary Search Tree you will understand that complexity - you may need to replace some deleted record by its successor)
- Insted of actually deleting
the record, the
system marks the record
as deleted
From time to time, the system rebuild the kd-tree from scratch to remove the deleted records.
- The delete operation is
very complex
and require
many block accesses
- Partial Match queries
- The query specifies conditions on some dimensions but not on all dimensions
Search Algorithm:
- For a dimension
for which the search value is
given:
- Take the (one) branch of the subtree for the search value
- For a dimension
for which the search value is
not given:
- Take the both branch of the subtree
Example:
- Find all person with
age = 50
- Analysis: how efficient is
the kd-tree ?
- Assume the kd-tree
is perfectly balance
(same height everywhere).
There are 2 dimensions and there are 2n levels:
- At level 1, we can
eliminate
half of
all records and
we need
only
to consider 1/2 of
all records
- At level 3, we can
eliminate
another half of
all remaining records and
we need
only
to consider 1/4 of
all records
- At level 5, we can
eliminate
another half of
all remaining records and
we need
only
to consider 1/8 of
all records
- At level 2n-1, we can
eliminate
another half of
all remaining records and
we need
only
to consider (1/2)n of
all records
- Assume the kd-tree
is perfectly balance
(same height everywhere).
- Range queries
- Find objects that are located either partial or wholly within a certain range
Search Algorithm:
- For the search range is
completely contained
by the left subtree, then:
- Take only the left branch of the subtree for the search value
- For the search range is
completely contained
by the right subtree, then:
- Take only the right branch of the subtree for the search value
- Otherwise
(the search range
saddles
at the search value):
- Search both subtrees
Example:
- Nearest neighbor queries:
- Very hard to optimize
using a kd-tree index
(Text book does not discuss the topic)
- Very hard to optimize
using a kd-tree index
- Where-am-I queries:
- No applicable