1. 2017, Fall Pusan National University Ki-Joune Li
Trees
2017, Fall
Pusan National University
Ki-Joune Li

2. Tree Definition Hierarchical Structure Recursion
Tree : Finite set of one or more nodes
One Root
A set of n (0) children, each of which is a tree (subtree)
Hierarchical Structure
Recursion
Recursive way of definition
Divide and Conquer a b c d e f
(a(b(d,e),c(f)))

3. Some Terms Root Child and Parent Sibling Degree of Tree Level
Leaf (or Terminal) Node
Internal nodes
Child and Parent
Sibling
Degree of Tree
Maximum Branching Factor
Level
Depth of Tree: Maximum Level
Internal nodes
Root
Level 1
Level 2
Level 3 a b c d e f
Leaf nodes

4. Binary Tree Binary Tree Tree whose maximum branch factor = 2
A finite set of nodes
empty or
Root, left subtree, and right subtree a b c d e f

5. Some Properties of Binary Tree
A binary tree T of depth k
Maximum number of nodes on level i : 2i-1
Maximum number of nodes in T : 2k – 1
n0 = n2 + 1, where n0 is the number of leaf nodes and n2 is the number of nodes with two children
Full Binary Tree
A Binary Tree of depth k with 2k – 1 nodes
No empty subtrees except nodes on level k
Complete Binary Tree
Nodes correspond to numberd from 1 to n a b d e c f g 1 2 4 5 3

6. Representation of Binary Tree : Array
If a binary tree T with n nodes is complete and i is the node number of the i-th node,
LeftChild(i) = 2i if 2i n, otherwise no left child
RightChild(i) = 2i + 1 if 2i +1 n, otherwise no left child
Only valid for complete binary graph 1 2 3 4 5 1 2 4 5 3
root
Left child
Right child
Parent

7. Representation of Binary Tree : Linked
Right Child
Data
Node
Left Child
Class BinaryTree {
private: TreeNode *root;
public:
// Operations };
Class TreeNode { friend class BinaryTree;
private: DataType data; TreeNode *LeftChild;
TreeNode *RightChild; };

8. Binary Tree Operations : Traversal
Prefix
Infix
Postfix
Level Order
X + Y * Z – X * Y -
- + X * Y Z * X Y
X + Y * Z – X * Y + *
X Y Z * + X Y * - X * X Y Y Z

9. Preorder Traversal + A B + A B void BinaryTree::Preorder() {
Preorder(root); }
void BinaryTree::Preorder(TreeNode *node) {
if(node!=NULL}{
cout << node->data;
preorder(node->leftChild);
preorder(node->rightChild); } + A B + A B

10. Level Order Traversal Not Recursive Queuing a b c d e f g Output a b c
void BinaryTree::LevelOrder() {
Queue *queue=new Queue; queue->add(root);
TreeNode *p;
while(queue->isEmpty()==NO) {
p=queue->delete();
cout << p->data;
queue->add(node->leftChild);
queue->add(node->rightChild); } d e f g
Output a b c
Queue a b c d e f g

11. Tree Copy C C A B A B Equal: Same Way
TreeNode* BinaryTree::Copy() {
return Copy(root); }
TreeNode* BinaryTree::Copy(TreeNode *node) {
TreeNode* p=NULL;
if(node!=NULL}{
p=new TreeNode;
p->data=node->data;
p->leftVhild=copy(node->leftChild);
p->rightChild=copy(node->rightChild); }
return p; C A B C A B
Equal: Same Way
Evaluation of propositional calculus

12. Binary Search Tree Binary Search Tree A kind of Binary Tree
For each node n in a binary search tree
Max(n.leftChild) ≤ n.data < Min(n.rightChild) 55 51 62 38 74 20 45 62 80 40 51

13. Binary Search Tree: Search
Search by Recursion
Search without Recursion
TreeNode* BST::SearchBST(TreeNode *node,int key) {
if(node==NULL) return NotFound;
else if(key==node->data) return node;
else if(key<node->data) return SearchBST(node->leftChild);
else return SearchBST(node->rightChild); }
TreeNode* BST::SearchBST(int key) {
TreeNode *t=root;
while(t!=NULL) {
if(key==t->data) return t;
else if(key < t->data) t=t->leftChild;
else /* key > t->data) t=t->rightChild); }
return NULL;

14. Binary Search Tree: Insertion
Boolean BST::Insert(int key) {
TreeNode *p=root; TreeNode *q=NULL;
while(p!=NULL) {
q=p;
if(key==p->data) return FALSE;
else if(key < p->data) p=p->leftChild;
else /*key > p->data*/ p=p->rightChild; }
TreeNode *t=new TreeNode(key);
if(root==NULL) root=t;
else if(key < q->data) q->leftChild=t;
else q->rightChild = t;
return TRUE;
+ 60 q 55 q p 38 74 p q 20 45 62 80 p 40 51 60

15. Binary Search Tree: Deletion
Three cases
Largest node 55 55 51 38 38 74 38 74 20 45 45 62 45 62 40 51 40 51 55 40 51 55
Case 1: Delete a Leaf Node
Case 2: Delete a node with a child
Case 3: Delete a node
with two children

16. Heap Heap (Max Heap) Priority Queue A Complete Binary Tree
DeleteQueue: Delete Max Element from Queue
A Complete Binary Tree
Data at a node is greater than the max of its two subtrees
Represented by array (or pointers) 74 45 55 23 34 12

17. Heap: Insertion O(log2 n) + 60 74 74 45 55 45 55 23 34 12 23 34 12 60
Heap[++k]=60 74
Heap[ k/2 ]=55 45 55
O(log2 n)
Heap[k]=60 23 34 12 60

18. Heap: Deletion O(log2 n) 74 12 45 55 45 55 45 55 34 23 12 34 23 12 34