Trees: basic definitions and terminology

Slides:



Advertisements
Similar presentations
Chapter 7. Binary Search Trees
Advertisements

Binary Trees CSC 220. Your Observations (so far data structures) Array –Unordered Add, delete, search –Ordered Linked List –??
1 abstract containers hierarchical (1 to many) graph (many to many) first ith last sequence/linear (1 to 1) set.
Binary Trees Chapter 6. Linked Lists Suck By now you realize that the title to this slide is true… By now you realize that the title to this slide is.
Binary Trees, Binary Search Trees CMPS 2133 Spring 2008.
Binary Trees, Binary Search Trees COMP171 Fall 2006.
Trees Chapter 8.
ITEC200 – Week08 Trees. 2 Chapter Objectives Students can: Describe the Tree abstract data type and use tree terminology such as.
Fall 2007CS 2251 Trees Chapter 8. Fall 2007CS 2252 Chapter Objectives To learn how to use a tree to represent a hierarchical organization of information.
Trees Chapter 8. Chapter 8: Trees2 Chapter Objectives To learn how to use a tree to represent a hierarchical organization of information To learn how.
Trees Chapter 8. Chapter 8: Trees2 Chapter Objectives To learn how to use a tree to represent a hierarchical organization of information To learn how.
Lists A list is a finite, ordered sequence of data items. Two Implementations –Arrays –Linked Lists.
Lec 15 April 9 Topics: l binary Trees l expression trees Binary Search Trees (Chapter 5 of text)
© 2006 Pearson Addison-Wesley. All rights reserved11 A-1 Chapter 11 Trees.
1 abstract containers hierarchical (1 to many) graph (many to many) first ith last sequence/linear (1 to 1) set.
Chapter 12 Trees. Copyright © 2005 Pearson Addison-Wesley. All rights reserved Chapter Objectives Define trees as data structures Define the terms.
CHAPTER 12 Trees. 2 Tree Definition A tree is a non-linear structure, consisting of nodes and links Links: The links are represented by ordered pairs.
Marc Smith and Jim Ten Eyck
Binary and Other Trees CSE, POSTECH. 2 2 Linear Lists and Trees Linear lists are useful for serially ordered data – (e 1,e 2,e 3,…,e n ) – Days of week.
Binary Trees Chapter 6.
Trees Chapter 8. 2 Tree Terminology A tree consists of a collection of elements or nodes, organized hierarchically. The node at the top of a tree is called.
Trees. Tree Terminology Chapter 8: Trees 2 A tree consists of a collection of elements or nodes, with each node linked to its successors The node at the.
Tree.
Advanced Algorithms Analysis and Design Lecture 8 (Continue Lecture 7…..) Elementry Data Structures By Engr Huma Ayub Vine.
Lecture Objectives  To learn how to use a tree to represent a hierarchical organization of information  To learn how to use recursion to process trees.
CS Data Structures Chapter 5 Trees. Chapter 5 Trees: Outline  Introduction  Representation Of Trees  Binary Trees  Binary Tree Traversals 
Lecture 81 Data Structures, Algorithms & Complexity Tree Algorithms GRIFFITH COLLEGE DUBLIN.
Lecture 10 Trees –Definiton of trees –Uses of trees –Operations on a tree.
Topic 14 The BinaryTree ADT Objectives Define trees as data structures Define the terms associated with trees Discuss tree traversal algorithms.
Trees Chapter 8. Chapter 8: Trees2 Chapter Objectives To learn how to use a tree to represent a hierarchical organization of information To learn how.
Spring 2010CS 2251 Trees Chapter 6. Spring 2010CS 2252 Chapter Objectives Learn to use a tree to represent a hierarchical organization of information.
CMSC 341 Introduction to Trees. 8/3/2007 UMBC CMSC 341 TreeIntro 2 Tree ADT Tree definition  A tree is a set of nodes which may be empty  If not empty,
Chapter 6 Binary Trees. 6.1 Trees, Binary Trees, and Binary Search Trees Linked lists usually are more flexible than arrays, but it is difficult to use.
Tree (new ADT) Terminology:  A tree is a collection of elements (nodes)  Each node may have 0 or more successors (called children)  How many does a.
Binary Trees, Binary Search Trees RIZWAN REHMAN CENTRE FOR COMPUTER STUDIES DIBRUGARH UNIVERSITY.
Tree Data Structures.
Trees Chapter 8. 2 Tree Terminology A tree consists of a collection of elements or nodes, organized hierarchically. The node at the top of a tree is called.
Starting at Binary Trees
TREES. What is a tree ? An Abstract Data Type which emulates a tree structure with a set of linked nodes The nodes within a tree are organized in a hierarchical.
Review 1 Queue Operations on Queues A Dequeue Operation An Enqueue Operation Array Implementation Link list Implementation Examples.
Tree Traversals, TreeSort 20 February Expression Tree Leaves are operands Interior nodes are operators A binary tree to represent (A - B) + C.
Lecture - 10 on Data Structures. 6:05:57 PM Prepared by, Jesmin Akhter, Lecturer, IIT,JU.
IKI 10100I: Data Structures & Algorithms Ruli Manurung (acknowledgments to Denny & Ade Azurat) 1 Fasilkom UI Ruli Manurung (Fasilkom UI)IKI10100I: Data.
Introduction to Trees IT12112 Lecture 05 Introduction Tree is one of the most important non-linear data structures in computing. It allows us to implement.
CMSC 341 Introduction to Trees. 2/21/20062 Tree ADT Tree definition –A tree is a set of nodes which may be empty –If not empty, then there is a distinguished.
Rooted Tree a b d ef i j g h c k root parent node (self) child descendent leaf (no children) e, i, k, g, h are leaves internal node (not a leaf) sibling.
TREES K. Birman’s and G. Bebis’s Slides. Tree Overview 2  Tree: recursive data structure (similar to list)  Each cell may have zero or more successors.
Trees Ellen Walker CPSC 201 Data Structures Hiram College.
CMSC 202, Version 5/02 1 Trees. CMSC 202, Version 5/02 2 Tree Basics 1.A tree is a set of nodes. 2.A tree may be empty (i.e., contain no nodes). 3.If.
BINARY TREES Objectives Define trees as data structures Define the terms associated with trees Discuss tree traversal algorithms Discuss a binary.
Chapter 7 Trees_ Part2 TREES. Depth and Height 2  Let v be a node of a tree T. The depth of v is the number of ancestors of v, excluding v itself. 
1 CMSC 341 Introduction to Trees Textbook sections:
IKI 10100: Data Structures & Algorithms Ruli Manurung (acknowledgments to Denny & Ade Azurat) 1 Fasilkom UI Ruli Manurung (Fasilkom UI)IKI10100: Lecture13.
DATA STRUCURES II CSC QUIZ 1. What is Data Structure ? 2. Mention the classifications of data structure giving example of each. 3. Briefly explain.
1 Trees. 2 Trees Trees. Binary Trees Tree Traversal.
Tree Representation and Terminology Binary Trees Binary Search Trees Pointer-Based Representation of a Binary Tree Array-Based Representation of a Binary.
What is a Tree? Formally, we define a tree T as a set of nodes storing elements such that the nodes have a parent-child relationship, that satisfies the.
Trees Chapter 15.
CSCE 210 Data Structures and Algorithms
Trees Another Abstract Data Type (ADT)
abstract containers sequence/linear (1 to 1) hierarchical (1 to many)
Binary Trees, Binary Search Trees
Introduction to Trees IT12112 Lecture 05.
General Trees & Binary Trees
Trees Another Abstract Data Type (ADT)
Trees Another Abstract Data Type (ADT)
Binary Trees, Binary Search Trees
Trees.
Binary Trees, Binary Search Trees
NATURE VIEW OF A TREE leaves branches root. NATURE VIEW OF A TREE leaves branches root.
Presentation transcript:

Trees: basic definitions and terminology Contrary to arrays, stacks, queues and sequences all of which are one- dimensional data structures, trees are two-dimensional data structures with hierarchical relationship between data items. Definition 1 A tree is a non-empty collection of vertices (nodes) and edges that satisfy certain requirements. Definition 2 A path in a tree is a list of distinct vertices in which successive vertices are connected by edges in the tree. One node in the tree is designated as the root. Each tree has exactly one path between the root and each of the other nodes. If there is more than one path between the root and some node, or no path at all, we have a graph. Definition 3 A set of trees is called a forest. Definition 4 (Recursive definition) A tree is either a single node or a root node connected to a forest.

Example of a tree: root siblings subtree internal nodes external nodes, or leaves

More definitions Definition 5 An ordered tree is a tree in which the order of children is specified. Definition 6 A level (depth) of a node in the number of nodes on the path from that node to the root. Definition 7 The height (maximum distance) of a tree is the maximum level among all of the nodes in the tree. Definition 8 The path length of a tree is the sum of the levels of all the nodes in the tree. Definition 9 A tree where each node has a specific number of children appearing in a specific order is call a multiway tree. The simplest type of a multiway tree is the binary tree. Each node in a binary tree has exactly two children one of which is designated as a left child, and the other is designated as a right child. Definition 10 (Recursive definition) A binary tree is either an external node, or an internal node and two binary trees.

Example of a binary tree root left child right child one or both children might be external nodes special external nodes with no name and no data associated with them

More binary trees examples 1. Binary tree for representing arithmetic expressions. The underlying hierarchical relationship is that of an arithmetic operator and its two operands. Arithmetic expression in an infix form: (A - B) + C * (E / F) + - * A B C / E F Note that a post-order traversal of this tree (i.e. visiting the left subtree first, right subtree next, and finally the root) returns the postfix form of the arithmetic expression, while the pre-order traversal (root is visited first, then the left subtree, then the right subtree) returns the prefix form of the arithmetic expression.

2. Binary tree with a heap property 2. Binary tree with a heap property. The underlying hierarchical relationship suggests that the datum in each node is greater than or equal to the data in its left and right subtrees. 87 84 63 68 79 12 32 67 6 10 8 9

3. Binary tree with an ordering property 3. Binary tree with an ordering property. The underlying hierarchical relationship suggests that the datum in each node is greater than the data in its left subtree, and less than or equal to the data in its right subtrees. 87 84 103 68 86 90 109 32 74 88 97 70 80

Wing Position C130 B747 Bulges C5A C141 4. Decision trees. The underlying hierarchical relationship depends on the nature of the domain represented by the binary tree. For example, consider a domain that consists of the following statements (from J.Ignizio “Intro to ES”): If the plane’s engine is propeller, then the plane is C130. If the plane’s engine is jet and the wing position is low, then the plane is B747. If the plane’s engine is jet and the wing position is high and no bulges are seen, then the plane is C5A If the plane’s engine is jet and the wing position is high and bulges are aft of wing, then plane is C141 . The following decision tree can be generated from these rules: Engine type Jet Propeller Wing Position C130 Low High B747 Bulges None Aft Wing C5A C141

Properties of binary trees 1. The number of external nodes is 1 more than the number of internal nodes. It is easy to see this if we start removing external nodes with their internal parent, one pair at a time (assume that a method removeAboveExternal(n) does this). At the end of this process, only the root with its two external children will remain. 2. The number of external nodes is at least h + 1, where h is the height of the tree, and at most 2h . The later holds for a full binary tree, which is a tree where internal nodes completely fill every level. 3. The number of internal nodes is at least h and at most 2h - 1. 4. The total number of nodes in a binary tree is at least 2*h + 1 and at most 2h+1 - 1. 5. The height, h, of a binary tree with n nodes is at least log n+1 and at most n. 6. A binary tree with n nodes has exactly n - 1 edges.

Full binary trees and complete binary trees Here is an example of a full binary tree: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 A complete binary tree is a full binary tree where the internal nodes on the bottom level all appear to the left of the external nodes on that level. Here is an example of a complete binary tree: 4 5 6

Properties of binary trees (cont.) The following property holds for a complete binary tree. Let i be a number assigned to a node in a complete binary tree. Then: 1. If i = 1, then this node is the root of the tree. If i > 1, then the parent of this node is assigned the number (i / 2). 2. If 2*i > n, then the corresponding node has no left child. Otherwise, the left child of that node is assigned the number 2*i. 3. If 2*i + 1 > n, then the corresponding node has no right child. Otherwise, the right child of that node is assigned the number 2*i + 1. This property suggests a trivial array-based representation of a complete binary tree, where i is the index of the node in the array. We will see that a slight modification in this representation allows us to represent any binary tree in a linear fashion.

The “generic” Binary Tree ADT We cannot provide a complete specification of the Binary Tree ADT, as we did with other ADT’s so far, because the hierarchical relationship in the binary tree cannot be uniquely defined. We define here only a set of basic operations on binary trees, and more specific binary tree ADT’s will be introduced as the need arrives. Operations (methods) on binary trees: empty () Returns true if the binary tree is empty getRoot () Returns the root node of the tree leftChild (node) Returns the left child of node. rightChild (node) Returns the right child of node. expandExternal(node) Makes node internal by creating its left and right children removeAboveExternal(node) Removes an external node together with its parent insert (node) Inserts node in the appropriate position in the tree delete (node) Deletes node preOrder() Visit the root, then the left subtree, then the right subtree postOrder () Visit the left subtree, then the right subtree, then the root inOrder() Visit the left subtree, then the root, then the right subtree levelOrder () Starting from the root, visit tree nodes level by level

Linear (or sequence-based) representation of a binary tree Linear representation of a binary tree utilizes one-dimensional array of size 2h+1 - 1. Consider the following tree: + level 0 (d = 0) - * level 1 (d = 1) A B C / level 2 (d = 2) E F level 3 (d = 3) To represent this tree, we need an array of size 23+1 - 1 = 15 The tree is represented as follows: 1. The root is stored in BinaryTree[1]. 2. For node BinaryTree[n], the left child is stored in BinaryTree[2*n], and the right child is stored in BinaryTree[2*n+1] i: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 BinaryTree[i]: + - * A B C / E F

Linear representation of a binary tree (cont.) Advantages of linear representation: 1. Simplicity. 2. Given the location of the child (say, k), the location of the parent is easy to determine (k / 2). Disadvantages of linear representation: 1. Additions and deletions of nodes are inefficient, because of the data movements in the array. 2. Space is wasted if the binary tree is not complete. That is, the linear representation is useful if the number of missing nodes is small. Note that linear representation of a binary tree can be implemented by means of a linked list instead of an array. For example, we can use the Positional Sequence ADT to implement a binary tree in a linear fashion. This way the above mentioned disadvantages of the linear representation will be resolved.

Linked representation of a binary tree Linked representation uses explicit links to connect the nodes. Example: 1 2 5 3 4 6 7 8 9 Nodes in this tree can be viewed as positions in a sequence (numbered 1 through 9). + - * A B C / E F

Binary tree nodes (linked representation) class BTNode { char data; BTNode leftChild; BTNode rightChild; BTNode parent; int pos; public BTNode () { } public BTNode (char newData) { data = newData; public BTNode (char newData, BTNode newLeftChild, BTNode newRightChild) { leftChild = newLeftChild; rightChild = newRightChild; ... methods setData, setLeftChild, setRightChild, getData, getLeftChild, getRightChild, displayBTNode follow next ...

Binary tree (linked representation) We can use a positional sequence ADT to implement a binary tree. Our example tree, in this case, we be represented as follows: position 1 2 3 4 5 6 7 8 9 data + - A B * C / E F leftChild 2 3 null null 6 null 8 null null rightChild 5 4 null null 7 null 9 null null parent null 1 2 2 1 5 5 7 7 class BTLRPS implements PSDLL { private BTNode header; private BTNode trailer; private int size; int position; ... class methods follow ... }

Traversals of a binary tree Preorder traversal public void preOrder (BTNode localRoot) { if (localRoot != null) { localRoot.displayBTNode(); preOrder(localRoot.leftChild); preOrder(localRoot.rightChild); } } Example Consider a tree with an ordering property, where nodes are inserted in the following order b i n a r y t r e e, i.e. b a i e n e r y t r The preorder traversal is: b a i e e n r y t r

Traversals of a binary tree (cont.) Post-order traversal public void postOrder (BTNode localRoot) { if (localRoot != null) { postOrder(localRoot.leftChild); postOrder(localRoot.rightChild); localRoot.displayBTNode(); } } The nodes in the example tree are traversed in post-order as follows: a e e r t y r n i b In-order traversal public void inOrder (BTNode localRoot) { inOrder(localRoot.leftChild); localRoot.displayBTNode(); inOrder(localRoot.rightChild); } } The nodes in the example tree are traversed in in-order as follows: a b e e i n r r t y

Traversals of a binary tree (cont.) Level-order traversal public void levelOrder (BTNode localRoot) { BTNode[] queue = new BTNode[20]; int front = 0; int rear = -1; while (localRoot != null) { localRoot.displayBTNode(); if (localRoot.leftChild != null) { rear++; queue[rear] = localRoot.leftChild; } if (localRoot.rightChild != null) { queue[rear] = localRoot.rightChild; } localRoot = queue[front]; front++; } } The nodes in the example tree are traversed in level-order as follows: b a i e n e r y t r

Example applications of binary tree traversals 3. Application of an in-order traversal: binary search trees A binary search tree is a tree with an ordering relationship between data in the nodes (i.e. all nodes with smaller data are in the left subtree and all nodes with greater or equal data are in the right subtree). See slide 7 for an example In-order traversal of a binary search tree produces an ordered list: 32 68 70 74 80 84 86 87 88 90 97 103 109 Binary search trees allow for a very efficient search (in log N time). The idea of the binary tree search is the following: to find a node with a given datum (the target), compare the target to the root; if it is smaller, go to the left subtree; if it is larger, go to the right subtree; if it is equal, stop.

Insertion in binary search tree Insert 9 in the the following tree: 3 2 15 1 11 7 13 Step 1: search for 9 3 search stops here 7 13 Step 2: insert 9 at the point where the search terminates unsuccessfully 7 13 That is, new nodes are always inserted at the leaf level. 9

Binary Tree with an ordering property: the insert method class BTLRADT { BTNode root; public BTLRADT () { } public BTNode getRoot () { return root; } public void insert (char newData) { BTNode newNode = new BTNode (); newNode.data = newData; if (root == null) root = newNode; else { BTNode temp = root; BTNode parent; while (true) { parent = temp; if (newData < temp.data) { //go left temp = temp.leftChild; if (temp == null) { parent.leftChild = newNode; return; } } else { // go right temp = temp.rightChild; if (temp == null) { parent.rightChild = newNode; return; }

Deletion in binary search tree Consider the tree: 3 7 2 15 Deleting 3 2 15 1 11 1 11 7 13 13 The following cases of deletions are possible: 1. Delete a note with no children, for example 1. This only requires the appropriate link in the parent node to be made null. 2. Delete a node which has only one child, for example 15. In this case, we must set the corresponding child link of the parent’s parent to point to the only child of the node being deleted. 3. Delete a node with two children, for example 3. The delete method is based on the following consideration: in-order traversal of the resulting tree (after delete operation) must yield an ordered list. To ensure this, the following steps are carried out: Step 1: Replace 3 with the node with the next largest datum, i.e. 7. Step 2: Make the left link of 11 point to the right child of 7 (which is null here). Step 3: Copy the links from the node containing 3 to the node containing 7, and make the parent node of 3 point to 7.

The Tree ADT Assuming that a general tree is implemented as a positional container, the following is an incomplete set of methods supported by the data structure: Container (positional sequence) methods: empty(): returns true if the container is empty. node(position): returns the node in position. elements(): returns an enumeration of all data stored at nodes of the tree. positions(): returns an enumeration of all the positions (nodes) of the tree. size(): returns the size of the container. replace (position, item): replaces the data at position with item. swap (position1, position2): swaps data in position1 and position2. Tree specific methods: getRoot(): returns the root node of the tree isRoot(position): returns true if the node in position is the root note. isInternal(position): returns true if the node in that position is an internal node. isExternal(position): returns true if the node in that position is an external node. parent(position): returns the parent of the node in position. children(position): returns a set of children of the node in position. siblings(position): returns a set of siblings of the node in position.

Computing a node’s depth and a tree’s height The depth of a tree node is a number of ancestors of that node, excluding the node itself. That is, the depth of the root is 0, while the depth of any other node is the depth of its parent plus one. The method, depth, can be implemented recursively as follows: public int depth (int position) { if (isRoot(position)) return 0; else return (1 + depth(parent(position))); } The height of the tree is equal to the maximum depth of external nodes of the tree. The method height can be implemented as follows: public int height () { int h = 0; Enumeration nodes = positions(); while (nodes.hasMoreElements()) { int nextNode = nodes.nextElement (); if (isExternal(nextNode)) h = Math.max(h, depth(nextNode)); } return h; }

Binary tree representation of a general tree Consider the following genealogical tree Jim Bill Katy Mike Tom Dave Mary Leo Bety Rog Lary Paul Peny Don We can represent it in the following binary tree format: 1 Jim 2 Bill 8 Katy 10 Mike 14 Tom 3 Dave 4 Mary 9 Leo 11 Bety 13 Rog 5 Lary 6 Paul 7 Peny 12 Don

Binary tree representation of a general tree (contd.) In the resulting binary tree, the left-child pointer (we can call it here the children pointer) points to the first child of the ordered list of children, while the right-child pointer (we can call it here the sibling pointer) points to the next sibling of a node. We can represent the resulting binary tree as a positional sequence: position 1 2 3 4 5 6 7 8 9 10 11 12 13 14 data Jim Bill Dave Mery Lary Paul Peny Katy Leo Mike Bety Don Rog Tom firstChild 2 3 null 5 null null null 9 null 11 12 null null null sibling null 8 4 null 6 7 null 10 null 14 13 null null null parent null 1 2 3 4 5 6 2 8 8 10 11 11 10 class TNode { private String data; private TNode children, sibling; int position; ... class methods follow ... }

Tree traversals Consider our example tree Jim Bill Katy Mike Tom Dave Mary Leo Bety Rog Lary Paul Peny Don Preorder traversal is: Jim Bill Dave Mary Lary Paul Peny Katy Leo Mike Bety Don Rog Tom Postorder traversal is: Dave Lary Paul Peny Mary Bill Leo Katy Don Bety Rog Mike Tom Jim

Preorder traversal of a general tree Preorder traversal works as follows: 1.) select a node and visit it and its children; 2.) go to the next node at the same level and do the same until all of the tree nodes are processed. Algorithm preOrder (TNode) visit TNode for each child TNodeChild of TNode do recursively perform preOrder(TNodeChild) Or, in JAVA: public void preOrder (TNode localRoot) { localRoot.displayTNode(); Enumeration localRootChildren = localRoot.children(localRoot.getPosition()); while (localRootChildren.hasMoreElements()) { TNode nextNode = localRootChildren.nextElement(); preOrder (nextNode); } } Note: If a general tree is represented as a binary tree, a preorder traversal of the general tree and the corresponding binary tree, produces the same result.

Postorder traversal of a general tree In postorder traversal, the tree is processed from left to right, ensuring that no node is processed until all nodes below it are processed. That is, Algorithm postOrder (TNode) for each child TNodeChild of TNode do recursively perform postOrder(TNodeChild) visit TNode Or, in JAVA: public void postOrder (TNode localRoot) { Enumeration localRootChildren = localRoot.children(localRoot.getPosition()); while (localRootChildren.hasMoreElements()) { TNode nextNode = localRootChildren.nextElement(); postOrder (nextNode); } localRoot.displayTNode(); } Note: If a general tree is represented as a binary tree, a postorder traversal of the general tree and the corresponding binary tree, do not generate the same result. However, the inorder traversal of the corresponding binary tree generates the same result as the postorder traversal of the general tree.

Ternary tree representation of a general tree If node siblings in a general tree form ordered lists, then we can represent the tree as a ternary tree. In a ternary tree, each node has the following attributes: left sibling, which is either null or points to a node whose data precedes that of a given node at the same level; data stored in the node; children, a pointer to the ordered list of children of that node, or null if the node has no children; right sibling, which is either null or points to a node whose data equals or follow that of a given node at the same level.

Ternary tree representation of a general tree (contd.) Consider the example tree: Jim Bill Katy Mike Tom Dave Mary Leo Bety Rog Lary Paul Peny Don Represented as a ternary tree, it looks like as follows: Bill Katy Mike Tom Dave Mary Leo Bety Rog Lary Paul Peny Don

Preorder traversal of a ternary tree The idea is the following: for each node do 1.) process the node, and 2.) access the binary tree representing its children, and process this binary tree inorder. Algorithm preorderTernary (ternaryNode) if (ternaryNode is internal node) { preorder (ternaryNode.leftSibling) process ternaryNode inorder (ternaryNode.children) preorder (ternaryNode.rightSibling) }