Self-adjusting%20structures

1
Self-adjusting structures

• In practice, we often search for the same element
  repeatedly. If we take advantage of this, each
  subsequent search can be faster.
• Example
• A structure that holds patient records. If a
  patient is currently in the hospital, his records
  will be accessed very often.
• Idea
• When an element is located, move it towards the
  "beginning" of the structure, so it can be found
  faster next time.
• Apply this to trees and lists.

2
Self-organizing lists

• Move-to-front method
• After the element is located, move it to the
  front of the list
• Transpose method
• After the element is located, swap it with its
  predecessor (unless it's already at the front).
• Count method
• Sort the list by the number of times each element
  has been accessed.

3
Self-adjusting trees

• Main features
• Ignore balance requirement
• When searching for an element, if it is found
  move it close to the root so that next time it
  will be found faster.
• Time requirements
• Even though individual operations may take a lot
  of time, a sequence of operations overall behaves
  as if each operation was logarithmic.
• In other words, inexpensive operations, such as
  searching for an element that happens to be very
  close to the root, cancel out expensive
  operations
• Space requirements
• Better than balanced trees, since there is no
  need to store balance or height or color in the
  nodes.

4
Self-adjusting trees

• Strategy 1
• If a node is accessed, move it towards the root
  by rotating once about its parent.
• Strategy 2 (Splaying)
• If a node is accessed, move it to the root
  through a sequence of rotations

5
Splay trees

• Splay trees sacrifice balance in favor of taking
  advantage of the fact that in practice, only a
  small subset of the data items stored in the tree
  is responsible for a large percentage of the
  accesses.
• Linear search time is now possible, but it does
  not happen very often because elements that are
  accessed frequently will soon be found very near
  or at the root of the tree.
• When analyzing splay tree operations we perform
  amortized analysis.
• In splay trees, it can be shown that a sequence
  of m operations takes at most O(mlgn) time,
  therefore the amortized cost of a single
  operation is O(lgn)

6
Splay trees bottom-up splaying

• Splaying moving an item to the root via a
  sequence of rotations
• In bottom-up splaying, we start at the node being
  accessed, and rotate from the bottom up along the
  access path until the node is at the root.
• The nodes that are involved in the rotations are
• the node being accessed (N)
• its parent (P)
• its grandparent (G)

7
Splay trees bottom-up splaying

• The rotation depends on the positions of the
  current node N, its parent P and its grandparent
  G

• If N is the root, we are done
• If P is the root, perform a single rotation

P
N
N
P

• If P and N are both left or both right children,
  first rotate P
• and then N as shown below

N
G
P
P
P
N
G
N
G
8
Splay trees bottom-up splaying

• If P is a left child and N is a right child (or
  vice versa), first
• rotate P and then N as shown below

G
G
N
P
N
P
G
N
P
9
Splay trees bottom-up splaying

• Search
• Once the node has been found, splay it
• Insert
• Insert the new node and immediately splay
• Delete
• Do a Search for the node to be deleted. It will
  end up at the root. Removing it will split the
  tree in two subtrees, the left (L) and the right
  (R) one
• Find the maximum in L and splay it to the root of
  L. This root will have no right child
• Make R a right child of L

10
Splay trees bottom-up splaying

• Example delete 8

11
Splay trees top-down splaying

• In bottom-up splaying we traveled the tree down
  to locate the node to be splayed and then up to
  perform the splaying.
• In top-down splaying
• We travel the tree only once (down).
• As we descend, we take the nodes that are found
  on the access path and move them out of the way
  while restructuring the pieces
• In the end we put everything back together.
• Time
• The amortized time is the same (logarithmic) but
  in practice this method is faster.

12
Splay trees top-down splaying

• At any time during the splaying of a node x, we
  have three subtrees
• L subtree containing nodes smaller than x,
  encountered on the access path towards x.
• T subtree containing x
• Its root is always the current node on the
  search.
• In the end, the root of T will be x.
• R subtree containing nodes larger than x,
  encountered on the access path towards x.
• The tree is descended two levels at a time.

13
Splay trees top-down splaying

• In the figures that follow, the access path is
  indicated by a thicker line.
• The tree is descended two levels at a time. We
  are interested in the current node, its child and
  its grandchild along the access path.
• There are three cases
• zig
• The target node is the child of the current node
• zig-zig
• The three nodes of interest form a straight line
• zig-zag
• The three nodes of interest form a zig-zag line

14
Splay trees top-down splaying
b
a
L
R
A
L
R
a
A
B
b
B
We are splaying node 'a'. Where should 'b'
go? 'b' is greater than 'a', so it is attached
to R Where in R should 'b' be attached? 'b' is
smaller than every other node in R, so it
should be placed in the lower left.
15
Splay trees top-down splaying
c
a
L
R
A
L
R
b
C
a
A
B
b
c
We are splaying node 'a'. Why did we rotate 'b'
and 'c'? Even though we are not enforcing any
balance restrictions, we still want to avoid a
very imbalanced tree. The rotation helps in that
(think of how R would look if we never rotated.)
B
C
16
Splay trees top-down splaying
c
b
L
R
B
L
R
a
C
b
A
B
a
c
A
C
We are splaying node 'b'. 'a' is smaller than
'b', and is placed in L 'c' is greater than 'b',
and is placed in R