View
7
Download
0
Category
Preview:
Citation preview
Tree Data Structures
REQUIRED READING
Before reading these slides, go through the following pages:
1. https://www.tutorialspoint.com/data_structures_algorithms/tree_data_structure.htm
2. https://www.tutorialspoint.com/data_structures_algorithms/tree_traversal.htm
3. https://www.tutorialspoint.com/data_structures_algorithms/binary_search_tree.htm
4. https://www.tutorialspoint.com/data_structures_algorithms/avl_tree_algorithm.htm
Trees• Productivity experts say that breakthroughs come by thinking
“nonlinearly.”
• Trees: non-linear data structures.
• They provide natural organization for data.
• E.g. file systems, graphical user interfaces, databases, Web sites, and other computer systems.
Trees
• A tree is an abstract data type that stores elements hierarchically.
• With the exception of the top element, each element in a tree has aparent element and zero or more children elements.
Tree Definition
• Formally, a tree T is a set of nodes storing elements in a parent-childrelationship with the following properties:• If T is nonempty, it has a special node, called the root of T, that has no parent.
• Each node v of T different from the root has a unique parent node w; everynode with parent w is a child of w.
Tree Elements• Node: item in the tree
• Branch: link connecting Nodes
• Root: "first" Node, no parent
• Leaf: "Bottom" Nodes, no children
• Parent: Node above children
• Child: Node below parent
• Siblings: Children of the same parent
• Levels: Number of rows
• Null tree: 0 levels (nothing in tree)
• Sub-tree: part of the tree that is also a tree
• A tree is either a null tree or a root with several sub-trees.
Typical Operations (ADT)
• insert()
• search()
• traverse()• in-order
• pre-order
• post-order
• isRoot()
• isEmpty()
• size()
• parent()
• children()
• siblings()
• root()
Different Types of Trees
• Tree
• Binary Tree
• Binary Search Tree
• AVL Tree
Tree Traversal Algorithms
• There are 3 standard tree traversals: pre-order, in-order, post-order
• Key:
• V visit (or look at the Node)
• L traverse the Left sub-tree
• R traverse the Right sub-tree
Tree Traversal Algorithms
• Pre-Order (V L-R):
• Look at the data at the root
• Pre-Order traverse all the subtrees from left to right.
•
• In-Order (L V R):
• In-order traverse the leftmost subtree
• Look at the data at the root of the subtree
• In-Order traverse all other subtrees from left to right.
•
• Post-Order (L-R V):
• Post-Order traverse all subtrees from left to right.
• Look at the root
Pre-Order Traversal: V L-R
Until all nodes are traversed:
Step 1 − Visit root node.
Step 2 − Recursively traverse left subtree.
Step 3 − Recursively traverse right subtree.
A → B → D → E → C → F → G
In-Order Traversal: L V R
Until all nodes are traversed:Step 1 − Recursively traverse left subtree.Step 2 − Visit root node.Step 3 − Recursively traverse right subtree.
D → B → E → A → F → C → G
Post-Order TraversalUntil all nodes are traversed −
Step 1 − Recursively traverse left subtree.
Step 2 − Recursively traverse right subtree.
Step 3 − Visit root node.
D → E → B → F → G → C → A
Pre-order traversal (VLR)
1 3 5 1
2 7
3 1 1
5
1 5 2 7
2 0
3 1 3 7
3 5
5 6 7 4
6 5
P r e -o r d e r t r a v e r sa l
The resulting sequence of numbers is as given in the diagram and the number sequence below
27 13 5 3 11 20 15 27 51 35 31 37 65 56 74
In-order traversal (LVR)
1 3 5 1
2 7
3 1 1
5
1 5 2 7
2 0
3 1 3 7
3 5
5 6 7 4
6 5
I n -o r d e r t r a v e r sa l
The resulting sequence of numbers is as given in the diagram and the number sequence below
3 5 11 13 15 20 27 27 31 35 37 51 56 63 74
Post-order traversal (LRV)
1 3 5 1
2 7
3 1 1
5
1 5 2 7
2 0
3 1 3 7
3 5
5 6 7 4
6 5
P o st-o r d e r tr a v e r sa l
The resulting sequence of numbers is as given in the diagram and the number sequence below
3 11 5 15 27 20 13 31 37 35 56 74 65 51 27
BST Implementation
struct node
{
int n;
struct node* left;
struct node* right;
}node;
Inserting into the BST
How do we insert a new value e.g. 25 into the tree?
• Root = 20, 25 is > than 20 so move right.
• Root is now = 30, 25 is < than 30 so move left.
• Root is now = 22, 25 is > than 22 so move right.
• Node does not exist to the right, so insert new Node 25 here.
Insert into the BST (this is just pseudocode)
insert(int data, node * tree)node *myTree = tree;
If myTreeis NULL
create root node
return
do until insertion position is located
If data > myTree.data
myTree = myTree->right i.e go to right subtree
if right subtree root is NULL
insert data into this root and return
else
myTree = myTree->left i.e. go to left subtree
if left subtree root is NULL
insert data into this root and return
end do
Searching in a BSTSearching a tree for a particular value e.g. 2:
• Root = 20, 2 is < 20 so move left
• Root = 18, 2 is < 18 so move left
• Root = 2 -> found.
For a value that does not exist e.g. 56:
• Root = 20, 56 is > 20 so move right
• Root = 30, 56 is > 30 so move right
• Root = 80, 56 is < 80 so move left
• Root does not exist -> not found
Searching through the BST
search(int key, node* tree)
if(tree == NULL)
return false
else if (key < tree->n)
return search(key, tree->left)
else if (key > tree->n)
return search(key, tree->right)
else // key == tree->n
return true
BST Search explanation
• We are looking for n, given tree, which is a node* to the root ofthe tree. We implement the logic fairly straightforwardly.
• If tree is NULL, then there are no nodes so we return false.
• The middle two conditions compare n, the value we are given, totree->n, which dereferences tree and accesses the n field storedwithin. If the n we are looking for is less, we search again with the leftchild of the tree by calling search(n, tree->left), whichmakes our problem smaller. Likewise, if n is greater, we search withthe right child of the tree.
• Finally, if the tree is not NULL and n is neither greater than or lessthan tree->n, then we found the value and can return true.
Performance of the BST
Note that the running time of search and update operations in a BSTvaries dramatically depending on the tree’s height.
On average, a binary search tree with n keys generated from a randomseries of insertions and removal of keys has expected height O(logn)
Height and Depth• Let p be a node of a tree T. The depth of p is the number of ancestors of
p, excluding p itself.
• Note that this definition implies that the depth of the root of T is 0.
• The depth of p’s node can also be recursively defined as follows:
• If p is the root, then the depth of p is 0
• Otherwise, the depth of p is one plus the depth of the parent of p
• The height of a tree T is the height of the root of T.
• The height of a tree is equal to the maximum depth of its external nodes (a.k.a leaf nodes).
Depth
Algorithm to find depth of a node, p, of a tree, T
depth(T, p):
if p.isRoot() then
return 0
else
return 1+depth(T, p.parent())
Balanced vs Unbalanced Trees
How many comparisons are needed to find the value 80?
Balanced vs Unbalanced Trees
• Balance Factor = height(left-subtree) − height(right-subtree)
If the Balance Factor is not more than 1 for all nodes, then the tree isbalanced
• A binary search tree is perfectly balanced if for every Node in thetree, the number of nodes to the left and to the right differ by one (orzero).
• If a tree is perfectly balanced, then the number of comparisonsneeded to find any particular value is minimised.
AVL Trees
• Ensuring that trees are balanced.
• height-balance property: For every internal node v of T, the heightsof the children of v differ by at most 1.
• Helps maintain a logarithmic height for the tree.
• Any binary search tree T that satisfies the height-balance property issaid to be an AVL tree, named after the initials of its inventors,Adelson, Velskii and Landis.
AVL Tree
The keys of the entries areshown inside the nodes,and the heights of thenodes are shown next tothe nodes.
The height of an AVL treestoring n entries is O(logn).
AVL Rotations
• What are AVL rotations and what are they useful for?
• Can you illustrate the following kinds of rotations?• Left Rotation
• Right Rotation
• Left-Right Rotation
• Right-Left Rotation
Recommended