Presentation made for the course CSE 225 on Splay tree.

1. Presentation
CSE 225
Team Members :
1.Dewan Farhat-AL-Jami, ID-132 0771 042
2.Md. Al Sahariar, ID- 131 0358 642
3.Wasee Sarwar, ID- 132 0858 042

2. Splay
Tree

3. What is Splay Tree?
 Splay trees are self-adjusting binary search
trees.
 A node in a Binary_Search_Tree is
"splayed" when it is moved to the root of the
tree by one or more "rotations".
 Whenever a node is accessed (Find, Insert,
Remove, etc.), it is splayed, thereby making it
the root.
 In addition to moving the accessed node to
the root, the height of the tree may be
shortened.

4. Splay tree Rules
Zig: Rotate the node about its parent
(left or right).
Zig_Zig: Rotate the parent about the
grandparent (left or right), then rotate
the node about its parent in the same
direction.
Zig_Zag: Rotate the node about its
parent (left or right), then rotate the
node about its grandparent in the other
direction.

5. Zig (Rotate Right):
splay* RR_Rotate(splay* k2)
{
splay* k1 = k2->lchild;
k2->lchild = k1->rchild;
k1->rchild = k2;
return k1;
}

6. Zig (Rotate Left):
splay* LL_Rotate(splay* k2)
{
splay* k1 = k2->rchild;
k2->rchild = k1->lchild;
k1->lchild = k2;
return k1;
}

7. Functions:
 Insert
 Delete
 Search

8. Inser
t

9. Insert (5)
5

10. Insert (10)
5
10

11. Insert (10)
5
10
It will move to the ROOT

12. Insert (10)
10
5
5 is less than 10 and moved to left
Now 10 is the ROOT

13. Insert (15)
10
5 15

14. Insert (15)
10
5 15
Now 15 will move to the ROOT

15. Insert (15)
15
10
5
10 is less than 15 and moved to
left
5 is less than 10 and moved to
left

16. Insert (12)
15
10
5 12

17. Insert (12)
15
10
5 12
Now 12 will move to the
place of 10

18. Insert (12)
15
12
10
5
12 moved to the place of 10
10 is less than 12 and moved to
left

19. Insert (12)
15
12
10
5
12 will move to the ROOT

20. Insert (12)
12
10
5
15
15 is greater than 12 and
moved to the right

21. Insert Implementation :
splay* Insert(int key, splay* root)
{
static splay* p_node = NULL;
if (!p_node)
p_node = New_Node(key);
else
p_node->key = key;
if (!root)
{
root = p_node;
p_node = NULL;
return root;
}
root = Splay(key, root);

22. if (key < root->key)
{
p_node->lchild = root->lchild;
p_node->rchild = root;
root->lchild = NULL;
root = p_node;
}
else if (key > root->key)
{
p_node->rchild = root->rchild;
p_node->lchild = root;
root->rchild = NULL;
root = p_node;
}
else
return root;
p_node = NULL;
return root;
}

23. Delet
e

24. Delete (4) from an existing tree
6
1 9
4 7
2

25. Delete (4) from an existing tree
6
1 9
4 7
2 Now 4 is going to be the
ROOT

26. Delete (4) from an existing tree
4
4 is the root now
1 6
2
7
9

27. Delete (4) from an existing tree
 4 has been Deleted and the tree has splited into
2 parts
1 6
2
7
9

28. Delete (4) from an existing tree
2
1
6
As (2) is the largest 9
element of the left sub
tree, it will become the
ROOT.
7

29. Delete function Implementation:
splay* Delete(int key, splay* root)
{
splay* temp;
if (!root)
return NULL;
root = Splay(key, root);
if (key != root->key)
return root;

30. else
{
if (!root->lchild)
{
temp = root;
root = root->rchild;
}
else
{
temp = root;
root = Splay(key, root->lchild);
root->rchild = temp->rchild;
}
free(temp);
return root;
}
}

31. Search

32. Find (10)
12
10
5
15

33. Find (10)
12
10
5
15
10 will move to the ROOT

34. Find (10)
10
5
10 is FOUND as it is
the ROOT now !
15
12
12 is greater than 10
and moved to right

35. Zig-Zig
1
2
3
4
5
6
1
2
3
6
5
4
Find (6)

36. 1
2
3
6
5
4
1
6
3
2 5
4
Find (6)
zig-zig

37. 1
6
3
2 5
4
6
1
3
2 5
4
Find (6)
Zig

38. Search function
Implementation:
splay* Search(int key, splay* root)
{
return Splay(key, root);
}

39. Splay function implementation:
splay* Splay(int key, splay* root)
{
if (!root)
return NULL;
splay header;
header.lchild = header.rchild = NULL;
splay* LeftTreeMax = &header;
splay* RightTreeMin = &header;
while (1)
{
if (key < root->key)
{
if (!root->lchild)
break;
if (key < root->lchild->key)
{
root = RR_Rotate(root);
if (!root->lchild)
break;
}

40. RightTreeMin->lchild = root;
RightTreeMin = RightTreeMin->lchild;
root = root->lchild;
RightTreeMin->lchild = NULL;
}
else if (key > root->key)
{
if (!root->rchild)
break;
if (key > root->rchild->key)
{
root = LL_Rotate(root);
if (!root->rchild)
break;
}
LeftTreeMax->rchild = root;
LeftTreeMax = LeftTreeMax->rchild;
root = root->rchild;
LeftTreeMax->rchild = NULL;
}

41. else
break;
}
LeftTreeMax->rchild = root->lchild;
RightTreeMin->lchild = root->rchild;
root->lchild = header.rchild;
root->rchild = header.lchild;
return root;
}

42. SPLAY TREE TIME COMPLEXITY
Sorted List Search Insertion Deletion
with arrays O(log n) O(n) O(n)
with linked list O(n) O(n) O(n)
With Splay
trees
O(log n) O(log n) O(log n)

43. Splay Tree Usage
 Memory allocators
 Routers
 Garbage collectors
 Data compression

44. Advantage :
 Simple Implementation
 Comparable performance
 Small memory footprint
 Working well with nodes containing
identical keys
Disadvantage:
 Height can be linear
 Extra management is needed if
multiple threads are allowed to perform
FIND operations.
 Splay tree can be worse than Static
tree.

45. Thank You !