tree and binary tree
TRANSCRIPT
Tree Data Structure
What is a Tree Data Structure● In computer science a tree is a abstract
mode of hierarchical structure. ● A Tree consist of nodes with a parent-child
relationship.● Tree data structure applications
– Organization charts
– File systems
– Programing environment
Tree Terminology● Root node which has no parent.● Internal node which at least one child.● Leaf node which has no child.● Ancestors nodes means parent, grand-
parent, grand-grand-parent etc.● Dept of a node means no of ancestors.● Height of a tree mean maximum dept of any
node.● Decent nodes means child, child-of-child etc.
Tree Terminology...
Height of Tree3
Levels
00
1
0
2
0
3
Binary Tree VS Not Binary Tree
5
3 7
4 14
9
23
18 27
16 41
32
15
5
3 7
4 14
9
23
18 27
16 41
32
15
Binary Tree Not a Binary Tree
Binary Tree ...
With One Child Binary Tree
Invalid binary tree
Binary tree
Strictly Binary Tree● Strictly BT either has 0 or 2 subtrees● A strictly BT with n leaves always contains
'2n-1' nodes
Full Complete BT
Expression Tree● Strictly BT used for expression trees
(A + (B-C))*((D-E) / (F+G-H))
*
+
A -
CB
/
- -
D
F
E + H
G
Tree Traversals● There are many ways to traverse BT, Lets
define operations needed to traverse a tree.– P → Process the Root of the binary tree.
– L → Traverse the Left SubTree of Root.
– R → Traverse the Right SubTree of Root.
● These operations performed in different order generate 6 different ways to traverse a binary tree: PLR, PRL, LPR, RPL, LRP and RLP
● Preorder traversal also called depth first order
1. P → Process the Root of the binary tree
2. L → Traverse the Left SubTree of Root in Preorder
3. R → Traverse the Right SubTree of Root in Preorder
Void preorder (BinaryTreeNode<T2>* root) {
If (root) {
cout<<root-> Data<< ' ';
Preorder(root->Left);
Preorder(root->Rift);
}
}
Expression:(A+B)*(C-D)
Preorder:*+AB-CD
*
+
A B
-
C D
Recursive Preorder Traversal (PLR)
Recursive Inorder Traversal (LPR)
Expression:(A+B)*(C-D)
Preorder:A+B*C-D
*
+
A B
-
C D
● Inorder traversal also called symmetric first order
– L → Traverse the Left SubTree of Root in Inorder
– P → Process the Root of the binary tree
– R → Traverse the Right SubTree of Root in Inorder
Void Inorder (BinaryTreeNode<T2>* root) {
If (root) {
Inorder(root->Left);
cout<<root-> Data<< ' ';
Inorder(root->Rift);
}
}
Expression:(A+B)*(C-D)
Preorder:AB+CD-*
*
+
A B
-
C D
– L → Traverse the Left SubTree of Root in Postorder
– R → Traverse the Right SubTree of Root in Postorder
– P → Process the Root of the binary tree
Void Postorder (BinaryTreeNode<T2>* root) {
If (root) {
Postorder(root->Left);
Postorder(root->Rift);
cout<<root-> Data<< ' ';
}
}
Recursive Postorder Traversal (LRP)
● Inorder ( ) {
– Create stack to store pointers to binary tree nodes
– Create pointer that point to current node under consideration
– Initialize current node pointer to point towards root node
– While (current node pointer has not processed whole tree) {
● While( current node pointer is not pointing towards empty tree) {– Push current node pointer on stack– Move current node towards left subtree
● }
● If stack is not empty {– do {
● Set current node pointer =Pop pointer from the stack● Process the current node (e.g. display through cout)
– } while curNode has empty right subtree and stack is not empty– Move current node towards right subtree
● }
– }
Iterative Inorder Traversal Using Stack
Iterative Inorder Traversal Using Stack
Operations Stack Inorder Expression Current Pointer
Start, Move to root Empty Empty *
Push * to stack, Move to + * Empty +
Push + to stack, Move to A * + Empty A
A is leaf, Process A, Pop +, Move to + * A +
Process +, Move to B * A + B
B is leaf, Process B, Pop *, Move to * Empty A + B *
Process *, Move to - Empty A + B * -
Push – to stack, Move to C - A + B * C
C is leaf, Process C, Pop -, Move to - Empty A + B * C -
Process -, Move to D Empty A + B * C - D
D is leaf, Process D, stack empty: Finish
Expression:(A+B)*(C-D)
Inorder: A+B*C-D
+
A B
-
C D
*
Iterative Inorder Traversal Using Stack● Void InOrder(BinaryTreeNode<T2>* root) {
– Stack< BinaryTreeNode <T2>* > stack;
– BinaryTreeNode<T2>* curNode =root;
– while(curNode !=NULL ) {● While(curNode !=NULL ){
– stack.Push (curNode);– CurNode = curNode ->Left;
● }● If (!stack.IsEmpty( ) ){
– Do {● curNode = stack.pop();● cout <<curNode->Data <<' ';
– } while( curNode-> Right ==NULL && !stack.IsEmpty( ) );– curNode = curNode->Right;
● } } }
Binary Search Tree (BST)A binary search tree is either empty or in which every node contains a key and satisfied the conditions.
1. The key in the left child of a node (if it exist) is less then the key in its parent node.
2.The key in the right child of a node (if it exist) is greater then the key in its parent node.
3.The left and right subtrees of the root are again binary search trees.
4.No two entries in a binary search tree may have a equal keys.
Complexity of BST
Data Structure Sorted Array Linked List BST
Searching Element O ( log2 N ) O ( N ) O ( log2 N )
Inserting Element O ( N ) O ( 1 ) O ( log2 N )
Deleting Element O ( N ) O ( 1 ) O ( log2 N )
Binary Search Tree ADT● 15, 5, 23, 3, 7, 2, 4, 14, 9, 18, 27, 16, 41, 32
15
5
3
2
7
4 14
9
23
18 27
16 41
32
Search value Algorithm in BST● Find (Any value In BST) {
Create a pointer to BST node: pNode
Initialize pNode = Root
While (Value at pNode ! = Key && pNode!=NULL) {If ( Value at pNode > Key )
pNode =pNode - > Left
elsepNode = pNode - > Right
}
Return pNode;
}
Searching Item from BSTFind 14:
Start at Root 15
14 < 15, Go Left
14 > 5, Go Right
14 > 7, Go Right
Found
15
5
3
2
7
4 14
9
23
18 27
16 41
32
Inserting Item into BST Algorithm● Insert (Key value in BST) {
– Create pointers to a BST node: pNode, pParent, newNode
– Initialize: pNode with Root, pParent with NULL, newNode Data = key value and its Left/Right pointer =NULL
– If ( Root ==NULL)
● Root = newNode
– Else if (Root !=NULL ) {
● pNode =Root
● pParent =NULL
● While (pNode !=NULL && pNode - > Data ! =value ) {– pParent =pNode– If (pNode - > Data > value )
● pNode = pNode - > Left– else
● pNode = pNode - > Right
● }
●
Inserting Item into BST Algorithm●
● If (pNode ! = NULL )– Display message value already into BST … Failed
● Else if (pNode == NULL ) {
if (pParent - > Data > value )● Pparent - > Left =newNode
– Else● Pparent - > Right = newNode
● }
– }
● }
Inserting Item into BST AlgorithmInsert 25:
Start at Root 15
25 > 15, Go Right
25 > 23, Go Right
25 < 27 , Go Left
Empty BST
Insert 25 Here
15
5
3
2
7
4 14
9
23
18 27
16 41
32
25
Inorder Predecessor● Inorder
predecessor of some value in the BST is the maximum value in its left subtree
● Inorder predecessor can never have the right child
● Algo: Predecessor( value ) {
– Create pointer to BST Node : pNode
– pNode = Find (value)
– If (pNode ==NULL)
● Return NULL;
– Else If(pNode → Left == NULL)
● Return NULL;
– Else
● Return Maximum(pNode-> Left->Data);
– }
Inorder Successor● Inorder successor
of some value in the BST is the minimum value in its right subtree.
● Inorder successor can never have the left child
● Algo: Successor( value ) {
– Create pointer to BST Node : pNode
– pNode = Find (value)
– If (pNode ==NULL)
● Return NULL;
– Else If(pNode → Right == NULL)
● Return NULL;
– Else
● Return Minimum(pNode-> Right->Data);
– }
15
5
3 7
4 14
9
23
18 27
16 41
32
25
Inorder PredecessorStart at Root 15Find maximum in left subtree (14)
Inorder SuccessorStart at Root 15Minimum in Right subtree 16
Inorder predecessor
Inorder Successor
Inorder Predecessor and Successor
Delete Node from BST● Three methods can use to delete a node
from BST– Node has both right and left BST empty then
just replace node with NULL
– Node has only right BST
– Node has only left BST
– Node has both right and left BST● Find the Inorder successor of value. Attach left
subtree of value as left subtree of its successor. Now value has only right subtree
● Find the Inorder Predecessor of value. Attach right subtree of value as right subtree of its predecessor. Now value has only left subtree
Delete Node from BST ...
15
5
3 7
4 14
9
Node has both right and left BST empty then just replace node with NULL
15
5
3 7
4 14
Delete Node from BST ...
15
5
3 7
4 14
9
Node has only right BST
15
5
3
4
14
9
Delete Node from BST ...
15
5
3 7
4 14
9
Node has only Left BST
15
5
3
4
7
9
Delete Node from BST ...
15
5
3 7
4 14
9
Node has bot Left & Right BST
Inorder predecessor
Inorder Successor
15
4
3 7
14
9
15
7
14
9
3
4
Replace with Inorder predecessor
Replace with Inorder successor