CS221A - Data Structures and Algorithms Binary Trees

CS221A – Data Structures and
Algorithms
Binary Trees

Binary Trees
 Tree with no node having more than two children.
 A finite set of nodes, one of which is designated as the root.
The root node may have at most two sub-trees, each of which
is also a binary tree.The two sub-trees of a given node are
ordered and we refer to them as left child and the right child.
Respectively.

Binary Trees
 Nodes in a binary tree may
have zero, one or two
children.
 The maximum number of
nodes at a given level/depth i
is
 2i-1 for i ≥ 1
(Considering the level/depth of root
node as i = 1)
A
B C
D E F
G H

Binary Trees
 The maximum number of
nodes for an entire
binary tree of depth k is.
2k-1 for k ≥ 1
 A full binary tree of
depth k is a binary tree
with 2k-1 nodes.
 That is the maximum
number of nodes a binary
tree can have.
A
B C
D E F
G H
Max. No of Node = 15

Binary Tree Implementation
 typedef struct TreeNode *PtrToNode;
 typedef struct *PtrToNode Tree;
 Typedef struct *PtrToNode Root;
 struct TreeNode
 {
 ElementType Element;
 Tree Left;
 Tree Right;
 }

 ElementVariable will serve as our data field.
 Left and Right points to the two sub-trees.
 Value NULL indicates the absence of a sub-tree.
 Root points at the root node of the tree.
 Root == NULL indicates an empty tree.

Binary Tree Traversal
 Visiting each node exactly once, is calledTraversal.
 When positioned at any given node a traversal function
may
 Continue down to left sub-tree or
 Continue down to right sub-tree or
 Or process the current node
 Still leaves open the question of when we should process
the data item.

 To process the data item we have the following options.
 Visit the node before moving down the left sub-tree.
(Preorder)
 Visit the node after traversing the left sub-tree but before
traversing the right sub-tree. (Inorder)
 Visit the after traversing both sub-trees. (PostOrder)

 InorderTraversal
1. Move down the tree as far left as possible
2. Visit the current node
3. Backup one node in the tree and visit it.
4. Move down the right sub-tree of the node visited in step 3.
5. Repeat the step 1 to 5 until all nodes have been processed.

1
2 3
4 5 6
8 9
7
10

1
2 3
4 5 6
8 9
7
10
Result : 8,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10, 5,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10, 5, 1,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10, 5, 1, 6,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10, 5, 1, 6, 3,

1
2 3
4 5 6
8 9
7
10
Result : 8, 4, 9, 2, 10, 5, 1, 6, 3, 7

 void InOrder(TreeNode Root)
 {
 if (Root !=null)
 {
 InOrder(RootLeft);
 PrintNode(RootElement);
 InOrder(RootRight);
 }
 }

 PreorderTraversal
 Visit the data item.
 Visit the left sub tree.
 Visit the right sub tree.

1
2 3
4 5 6
8 9
7
10

Result : 1,
2 3
4 5 6
8 9
7
10

Result : 1, 2,
3
4 5 6
8 9
7
10

Result : 1, 2, 4,
3
5 6
8 9
7
10

Result : 1, 2, 4, 8,
3
5 6
9
7
10

Result : 1, 2, 4, 8, 9,
3
5 6 7
10

Result : 1, 2, 4, 8, 9, 5,
3
6 7
10

Result : 1, 2, 4, 8, 9, 5, 10,
3
6 7

Result : 1, 2, 4, 8, 9, 5, 10, 3,
6 7

Result : 1, 2, 4, 8, 9, 5, 10, 3, 6
7

Result : 1, 2, 4, 8, 9, 5, 10, 3, 6, 7

 void PreOrder(TreeNode Root)
 {
 {
 PreOrder(RootLeft);
 PreOrder(RootRight);
 }
 }

 PostorderTraversal
 Visit the left sub tree.
 Visit the right sub tree.
 Visit the data item.

1
2 3
4 5 6
8 9
7
10

Result : 8,
2 3
4 5 6
9
7
10
1

Result : 8, 9
2 3
4 5 6 7
10
1

Result : 8, 9, 4,
2 3
5 6 7
10
1

Result : 8, 9, 4, 10,
2 3
5 6 7
1

Result : 8, 9, 4, 10, 5,
2 3
6 7
1

Result : 8, 9, 4, 10, 5, 2,
3
6 7
1

Result : 8, 9, 4, 10, 5, 2, 6,
3
7
1

Result : 8, 9, 4, 10, 5, 2, 6, 7
3
1

Result : 8, 9, 4, 10, 5, 2, 6, 7, 3
1

Result : 8, 9, 4, 10, 5, 2, 6, 7, 3, 1

 void PostOrder(TreeNode Root)
 {
 {
 PostOrder(RootLeft);
 PostOrder(RootRight);
 }
 }

 Breadth FirstTraversal
 Process nodes by level
 Left to right within the level

 Breadth First Traversal
1
2 3
4 5 6
8 9
7
10

Result : 1,
2 3
4 5 6
9
7
108

Result : 1, 2,
3
4 5 6
9
7
108

Result : 1, 2, 3,
4 5 6
9
7
108

Result : 1, 2, 3, 4,
5 6
9
7
108

Result : 1, 2, 3, 4, 5
6
9
7
108

Result : 1, 2, 3, 4, 5, 6,
9
7
108

Result : 1, 2, 3, 4, 5, 6, 7,
9 108

Result : 1, 2, 3, 4, 5, 6, 7, 8,
9 10

Result : 1, 2, 3, 4, 5, 6, 7, 8, 9,
10

Result : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Result : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
 Breadth FirstTraversal

 void BreadthFirst(TreeNode Root)
 {
 // Solve It
 }

Expression Trees
 Is a BinaryTree.
 Leaves of an expression tree are operand, such as
constants or variable names.
 Other nodes contain the operators.

Expression Trees
 We can evaluate and expression tree by applying the
operator at the root to the values obtained by recursively
evaluating the left and right sub-trees.
(a + b * c) +((d * e + f) *g)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 InorderTraversal (left, Root, Right)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 InorderTraversal (left, Root, Right)
 a+ b * c + d * e + f * g (infix notation)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 PreorderTraversal (Root, Left, Right)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 PreorderTraversal (Root, Left, Right)
 + + a * b c * + * d e f g (Prefix Notation)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 PostorderTraversal (Left, Right, Root)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 PostorderTraversal (Left, Right, Root)
 a b c * + d e * f + g * + (Postfix Notation)
*
b c
a
+
d e
*
+
f
*
g
+

Expression Trees
 Postfix Expression to ExpressionTree
 a b + c d e + * *

Expression Trees
 a b + c d e + * *
a
b
a, b are operands push pointers to
their nodes in the stack

Expression Trees
 a b + c d e + * *
a b
+ operator , pop the last two
pointers, create a new expression
tree. Push pointer to its root back in
stack.
+

Expression Trees
 a b + c d e + * *
a b
push pointers to the nodes of the
operands c, d & e
+
c
d
e

Expression Trees
 a b + c d e + * *
a b
+ operator , pop the last two
stack.
+
c
d e
+

Expression Trees
 a b + c d e + * *
a b
* operator , pop the last two
stack.
+
c
d e
+
*

Expression Trees
 a b + c d e + * *
a b
* operator again, pop the last two
stack.
+
c
d e
+
*
*

Binary Search Trees
 A binary tree , used for searching.
 Each node in the tree is assigned a key value.
 Keys are assumed as distinct.

Binary Search Trees
 For every node X in
the tree
 Left Sub-tree key
values < X < Right
Sub-tree key values.
4
3 5
1
2
7 9
8
10
11
12
13
6

Binary Search Trees Implementation
 typedef struct TreeNode *PtrToNode;
 typedef struct *PtrToNode SearchTree;
 typedef struct *PtrToNode Position;
 struct TreeNode
 {
 TreeNode Left;
 TreeNode Right;
 }

Binary Search Tree Implementation
 SearchTree MakeEmpty(SearchTree T)
 {
 if (T != NULL)
 {
 MakeEmpty(TLeft);
 MakeEmpty(TRight);
 free(T);
 }
 return NULL;
 }

 FindValue
 Requires returning a pointer to the node in treeT that has the
key value.
 IfT is Null return NULL, if the key stored at T is X, we can
returnT. Otherwise depending on the less than and greater
than relationship we can traverse the tree recursively either on
the left sub tree or the right subtree.

 Position Find(ElementType X, SearchTree T)
 {
 if (T == NULL)
 {
 return NULL;
 }
 if (X < TElement)
 {
 return Find(X, TLeft);
 }else
 if (X > TElement)
 {
 return Find(X, TRight);
 }
 else
 return T;
 }

 Find MinimumValue
 Get us the minimum or smallest key value in the tree.
 For Find Minimum, start at the root and go left as long as there
is a left child.

 Position FindMin(SearchTree T)
 {
 if (T == NULL)
 {
 return NULL;
 }else
 if (TLeft == NULL)
 {
 return T;
 }else
 Return FindMin(TLeft);
 }

 Find MaximumValue
 Get us the maximum or largest key value in the tree.
 For Find Maximum start at the root and go right as long as
there is a right child.

 Position FindMax(SearchTree T)
 {
 if (T == NULL)
 {
 return NULL;
 }else
 if (TRight == NULL)
 {
 return T;
 }else
 Return FindMin(TRight);
 }

 Insert (Duplication Not Allowed)
 Proceed down the tree in similar fashion as we did in Find
Function.
 Insert X at the last spot on the path traversed.

 SearchTree Insert(ElementType X, SearchTree T)
 {
 if (T == NULL)
 {
 T = malloc(sizeof(struct TreeNode));
 TElement = X;
 TLeft = TRight = NULL;
 }else
 {
 TLeft = Insert(X,TLeft);
 } else
 {
 TRight = Insert(X,TRight);
 } else
 return T;
 }

 Delete
 If the node is a leaf , it can be deleted immediately.
 If the node has one child, the node can be deleted after its
parent adjust a pointer to bypass the node.
 If the node has two children, replace the data of this node with
the smallest data of the right sub-tree and recursively delete
that node.

 Delete
R
S
T U
Node to be deleted

 Delete
R
S
T U
Node to be deleted
R
T
U
Before Deletion
After Deletion

 Delete
6
2
1 4
Node to be deleted
3
8

 Delete
6
2
1 4
Node to be deleted
3
8
6
2
1 4
3
8
6
2
1 4
3
8

 Delete
6
2
1 5
Node to be deleted
3
8
4

 Delete
6
2
1 5
Node to be deleted
3
8
4
6
2
1 5
3
8
4
6
2
1 5
3
8
4

 SearchTree Delete(ElementType X, SearchTree T)
 {
 Position TempCell
 if (T == NULL)
 {
 Error(“Element Not Found”);
 }else
 {
 TLeft = Delete(X,TLeft);
 } else
 {
 TRight = Delete(X,TRight);
 } else
// contd. On next page
 }

 SearchTree Delete(ElementType X, SearchTree T)
 {….
 If (TLeft && TRight) // left and right child //
 {
 TmpCell = FindMin(TRight);
 TElement = TmpCellElement;
 TRight = Delete(TElement, TRight);
 }
 Else
 {
 TmpCell = T;
 If (TLeft == NULL) // leaves , no children //
 {
 T = TRight;
 }else if (TRight == NULL)
 {
 T = TLeft;
}
 Free(TmpCell);
 }
 return T;
 }

AVL Trees
 Binary search tree with a balance condition.
 The balance condition must be easy to maintain and it
ensures that the dept of the tree is O(log n).
 Idea is to acquire same height on the left and right sub-
trees.
 Prevent a worst case running time of O(n). i.e. a left-iest
or right-iest tree.A tree structure looking like a linear list.

AVL Trees
 Balanced Condition
 left height(n) = 0 if n has no left child.
 = 1 + height(left child(n)) for all other nodes.
 right height(n) = 0 if n has no right child.
 = 1 + height(right child(n)) for all other nodes.
 Balance(n) = right height(n) – left height(n)

AVL Trees
 Balance condition indicates the relative height of its right
sub-tree compares to its left.
 If the balance is positive the right sub-tree has greater
depth than the left sub-tree.
 If the balance is negative the left sub-tree has greater
depth than the right sub-tree.
 A binary tree is an AVL tree if and only if every node in
the tree has a balance of -1 , 0 or +1.

AVL Trees
x
2
5
0 0
1
0 0 0 0
1 1
2
51
0 0 1 0
1 2
4
0 0
balance = right height – left height
= 0 - 0 (AVL Tree)
= 2 – 1 = 1 (AVL Tree)
= 1 – 1 = 0 (AVL Tree)

AVL Trees
3
51
0 1 0 0
2 1 5
1
8
0 0
= 1 – 3 = -2 (Non-AVL Tree)
= 1 – 2 = -1 (AVL Tree)
2
41
0 0
1 2
3
0 0
2
0 0
1 0
3

AVL Trees
 Height of the two child sub-trees of any node differ by at
most one; therefore it is also said to be height-balanced.
 Searching, Insert and Delete all take O(log n) in both
average and worst cases.Where n is the number of nodes
in the tree prior to the operation.
 Insertions and deletions may require the tree to be
rebalanced by one or more tree rotation.
 Node with balance factor 1,0 or -1 is considered
balanced.
 Node with any other balance factor is called unbalance
and need to be rotated or rebalanced.

AVL Trees
7
6
5
8
= ? – ? = ?
2
41
3

AVL Trees
7
6
5
8 balance = right height – left height
= 0 – 2 = -2 ( Non-AVL)
2
41
3

AVL Trees
7
6
5
8
= 0 – 2 = -2 ( Non-AVL)
2
41
3

AVL Trees
7
6
5
8
= 2 – 3 = -1 (AVL Tree)
2
41
3

AVL Trees
3
2
4
= ? – ? = ?
1
5

AVL Trees
3
2
4
= 2 – 0 = 2 (Non- AVL)1
5

AVL Trees
3
2
4
= 2 – 1 = 1 (AVL Tree)
1
5

AVL Trees
3
2
4
= ? – ? = ?
1
5
6

AVL Trees
3
2
4
= 3 – 1 = 2 (Non AVL)
1
5
6

AVL Trees
3
2
4
= 2 – 2 = 0 (AVL Tree)
1
5
6

AVL Trees
3
2
4
= ? - ? = ?
1
5
6
7

AVL Trees
3
2
4
= 2 - 0 = 2 (Non AVL)
1
5
6
7

AVL Trees
3
2
4
= 2 - 2 = 0 (AVL Tree)
1
5
6
7

AVL Tree Implementation
 typedef struct AvlNode *Position;
 typedef struct AvlNode *AvlTree;
 struct AvlNode
 {
 Avltree Left;
 Avltree Right;
 int Height;
 }

AVL Tree Insertion
 Trace the path from the root node to a leaf node.
 Insert the new node.
 Retrace the path back up to the root, adjusting balances
along the way.
 If a nodes balance is out of the bound condition i.e.
-1 > balance >1. rotate and rebalance.

AVL Tree Insertion
 Rotation
 Singly Rotation
 It preserves the Ordered property of the tree.
 It restores all nodes to appropriate AVL balance.
 Preserves the Inorder traversal of the tree i.e. Inorder traversal will
access nodes in the same order after transformation.
 Only modify three pointers to accomplish the rebalancing.

AVL Trees Implementation
 Singly Rotation ( Left and Right )
 Right Rotation of Root Q results in Q stepping down a
hierarchy. P becomes Root with Q as right child and right child
of P becomes left child of Q.

AVL Tree Rotation
k2
X
Y
Z
k1
k2
X
Y Z
k1

AVL Tree Rotation
k2
X Y
Z
k1
k2
X Y
Z
k1

 Position LeftRotation(Position K2)
 {
 Position K1 = K2 Right;
 K2Right = K1Left;
 K1Left = K2;
 K2Height = Max(Height(K2Right),
Height(K2Left))+1;
 K1Height = Max(Height(K1Right), K2Height) + 1;
 return K1;
 }

 Position RightRotation(Position K2)
 {
 Position K1 = K2 Left;
 K2Left = K1Right;
 K1Right = K2;
 K2Height = Max(Height(K2Left),
Height(K2Right))+1;
 K1Height = Max(Height(K1Left), K2Height) + 1;
 return K1;
 }

AVL Tree Insertion
 AvlTree Insert(ElementType X, AvlTree T)
 {
 Condition 1: T == Null
 Condition 2: X < TElement
 Condition 3: X > TElement
 }

AVL Tree Insertion
 { // T== Null
 If (T == Null)
 {
 T = malloc(sizeof(struct AvlNode));
 TElement = X;
 THeight = 0;
 TLeft = Null;
 TRight == Null;
 }
 .. cont
 }

AVL Tree Insertion
 { // X < TElement
 If (X < TElement)
 {
 if (Height(TLeft) – Height(TRight) == 2)
 {
 T = RightRotation(T);
 }
 }
 .. cont
 }

AVL Tree Insertion
 { // X > TElement
 If (X > TElement)
 {
 if (Height(TRight) – Height(TLeft) == 2)
 {
 T = LeftRotation(T);
 }
 }
 THeight = Max(Height(TLeft),Height(TRight))+1;
 return T;
 }

 Position LeftRightRotation(Position K3)
 {
 K3Left = LeftRotation(K3Left)
 return RightRotation(K3);
 }
 Position RightLeftRotation(Position K3)
 {
 K3Right = RightRotation(K3Right)
 return LeftRotation(K3);
 }

AVL Trees
3
2
4
1
5
6
7 16
15
14

AVL Trees
3
2
4
1
5
6
7
16
15
14

AVL Trees
3
2
4
1
5
6
7
16
15
14
Insert 13

AVL Trees
3
2
4
1
5
6
7
16
15
14
13

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
Insert 12

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
Insert 11

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11
Insert 10

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11
10

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11
10
Insert 8

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11
10
8Insert 9

AVL Trees
3
2
4
1
5
6
7
16
15
14
13
12
11
10
8
9

AVL Tree Insertion
 { // X < TElement
 If (X < TElement)
 {
 if (Height(TLeft) – Height(TRight) == 2)
 {
 If (x<TLeftElement)
 T = RightRotation(T);
Else
T = RightLeftRotation(T);
 }
 }
 .. cont
 }

AVL Tree Insertion
 { // X > TElement
 If (X > TElement)
 {
 if (Height(TRight) – Height(TLeft) == 2)
 {
 If (x>TRightElement)
 T = LeftRotation(T);
Else
T = LeftRightRotation(T);
 }
 }
 THeight = Max(Height(TLeft),Height(TRight))+1;
 return T;
 }

CS221A - Data Structures and Algorithms Binary Trees

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (19)

Similaire à CS221A - Data Structures and Algorithms Binary Trees

Similaire à CS221A - Data Structures and Algorithms Binary Trees (20)

Dernier

Dernier (20)

CS221A - Data Structures and Algorithms Binary Trees