To implement binary trees, we have two prototypes: BTNode and BinaryTree.

Size: px

Start display at page:

Download "To implement binary trees, we have two prototypes: BTNode and BinaryTree."

Katherine Webb
6 years ago
Views:

1 Binary Trees To implement binary trees, we have two prototypes: BTNode and BinaryTree. A BTNode is very much like a ListNode except that, instead of having one instance variable whose value is a reference, it has two: leftchild and rightchild. We define get and set methods for all three instance variables. If the constructor is called with fewer than three arguments, leftchild is set to null. If the constructor is called with fewer than two arguments, rightchild is also set to null. The tostring method simply returns what s returned by the tostring method of whatever is the value of the data instance variable. The inordertraversal property of the prototype is set to the BTNode_inorderTraversal function defined outside the constructor. This method performs an inorder traversal of the binary tree rooted at the current BTNode. As long as the left child is not null, it recursively invokes the inordertraversal method of the left child. Then it outputs the value of the data instance variable. Finally, as long as the right child is not null, it recursively invokes the inordertraversal method of the right child. 176

2 function BTNode( data, leftchild, rightchild ) this.data = data; this.leftchild = leftchild null; this.rightchild = rightchild null; this.getdata = function() return this.data; ; this.setdata = function( data ) this.data = data; ; this.getleftchild = function() return this.leftchild; ; this.setleftchild = function( leftchild ) this.leftchild = leftchild; ; this.getrightchild = function() return this.rightchild; ; this.setrightchild = function( rightchild ) this.rightchild = rightchild; ; this.tostring = function() return this.data.tostring() ; this.inordertraversal = BTNode_inorderTraversal; function BTNode_inorderTraversal() if ( this.leftchild!= null ) this.leftchild.inordertraversal(); document.writeln( this.data + "<br>" ); if ( this.rightchild!= null ) this.rightchild.inordertraversal(); 177

3 The following is the file that tests BTNode. It creates the binary tree shown at right, with btnode a reference to its root. b btnode a c It then invokes the inordertraversal method of btnode. d var btnode = new BTNode( "a", new BTNode( "b", null, new BTNode( "d" ) ), new BTNode( "c" ) ); btnode.inordertraversal(); The following is the HTML file that executes these two files. btnode.js contains the BTNode constructor. TestBTNode.js contains the test code. <html> <head> <title>tests</title> <script type = "text/javascript" src = "btnode.js"> </script> <script type = "text/javascript" src = "testbtnode.js"> </script> </head> </html> 178

4 The following is the rendering: b d a c A BinaryTree has one instance variable, root, which is a reference to the root node of a binary tree made up of BTNode nodes. Instances of this prototype are basically just packages for binary trees made up of BTNode nodes. The constructor has one formal parameter, rootdata. If the constructor is invoked without any argument, rootdata is undefined, and the root instance variable is set to null. If a value is supplied for rootdata, then this value is passed to the BTNode constructor, and the new BTNode is assigned to the root instance variable. The code to do this is this.root = rootdata? new BTNode( rootdata ) : null; We define get and set methods for the root. An inorder traversal method is defined for binary trees. This calls the inordertraversal method of root as long as root isn t null. It encloses the output generated by this method of root in <p> tags. 179

5 Conceptually, a binary tree is a recursive structure: its children are binary trees. We should thus have a method that constructs a binary tree from left and right subtrees and data for the root. We define a class method for this that has three formal parameters: rootdata: the data value for the new root leftsubt, rightsubt: references to the left and right subtrees The first step is to create a new BinaryTree with rootdata as the value of the data instance variable of the root node: bt = new BinaryTree( rootdata ); Next, we have to unpackage the reference to the root of the left subtree: leftsubt.root This is assigned to the leftchild instance variable of the root node of our new BinaryTree object: bt.root. leftchild = leftsubt.root; A similar statement sets the rightchild instance variable of the root to a reference to the root of the right subtree: bt.root.rightchild = rightsubt.root; The entire file is shown on the next page. 180

6 function BinaryTree( rootdata ) this.root = rootdata? new BTNode( rootdata ) : null; this.setroot = function( root ) this.root = root; ; this.getroot = function() return this.root; ; function BinaryTree_inorderTraversal() document.writeln( "<p>" ); if ( this.root!= null ) this.root.inordertraversal(); document.writeln( "</p>" ); BinaryTree.prototype.inorderTraversal = BinaryTree_inorderTraversal; function BinaryTree_makeBT( rootdata, leftsubt, rightsubt ) bt = new BinaryTree( rootdata ); bt. root.leftchild = leftsubt.root; bt.root.rightchild = rightsubt.root; return bt; BinaryTree.makeBT = BinaryTree_makeBT; 181

7 The following is test code for BinaryTree. It creates the binary tree shown at right and assigns to bt the BinaryTree that packages a reference to the root of this tree. It then invokes the inordertraversal method of bt. b bt.root a c d The constructor BTNode is used to construct singleton binary trees. BinaryTree.makeBT is used to construct a binary tree with at least one non-null subtree. var bt = BinaryTree.makeBT( "a", BinaryTree.makeBT( "b", new BinaryTree( null ), new BinaryTree( "c" ) ), new BinaryTree( "d" ) ); bt.inordertraversal(); 182

8 The following is the HTML file that executes both these files and the file with the definition of BTNode (since BinaryTree uses BTNode). BtNode.js contains the BTNode constructor. binarytree.js containts the BinaryTree constructor. TestBinaryTree.js contains the test code. <html> <head> <title>tests</title> <script type = "text/javascript" src = "btnode.js"> </script> <script type = "text/javascript" src = "binarytree.js"> </script> <script type = "text/javascript" src = "testbinarytree.js"> </script> </head> </html> The following is the rendering: b c a d 183

9 A binary search tree is a binary tree with the following invariant: At any node n in the tree, all the values in the left subtree of n are less than or equal to the value at n, and all the values in the right subtree of n are greater than or equal to the value at n. To implement binary search trees, we have two prototypes: BSTNode, which inherits from BTNode and BDTree, which inherits from BinaryTree. We develop BSTNode; BSTree (much simpler) is left as an exercise. We want the BSTNode constructor to be able to take zero or more arguments. If it takes more than one argument, it should produce a binary search tree with all the arguments inserted into it. If there is zero or one argument, we can use the constructor for BTNode. So the constructor begins: function BSTNode() this.base = BTNode; if ( arguments.length == 0 ) this.base(); else if ( arguments.length == 1 ) this.base( arguments[ 0 ] ); else 184

10 If there is more than one argument, we must do some insertion into the binary tree. So first consider the insert method. This has one formal parameter, val, the value to be inserted. If val is less than the data value at the current node, then it should be inserted in the left subtree of that node. If the left child is null, then we make a new node with val as its data and assign it as the left child of the current node: this.leftchild = new BSTNode( val ); If not, then we invoke the insert method recursively on the subtree rooted at the left child: this.leftchild.insert( val ); If val is greater than or equal to the data value at the current node, then it should be inserted in the right subtree of that node. This is similar to the case where we go left, but we work with the right child rather than the left child. 185

11 The entire body of the method is: if ( val < this.data ) if ( this.leftchild == null ) this.leftchild = new BSTNode( val ); else this.leftchild.insert( val ); else if ( this.rightchild == null ) this.rightchild = new BSTNode( val ); else this.rightchild.insert( val ); Now, in the constructor, when arguments.length > 1, we call an initialization method that inserts all the values into a binary search tree. The values of the data, leftchild, and rightchild instance variables of the node at the root of this tree are passed to the BSTNode constructor. var temp = this.initialize( arguments ); this.base( temp.data, temp.leftchild, temp.rightchild ); 186

12 The initialization method takes the arguments (formal parameter args) to the BSTNode constructor. It creates a root node with the first element of args as its data. It then inserts the remaining elements of args into the tree rooted at this node and returns a reference to it. The code for the body of this method is: var root = new BSTNode( args[ 0 ] ); for ( var i = 1; i < args.length; i++ ) root.insert( args[ i ] ); return root; The entire file defining BSTNode is given on the next page. 187

13 function BSTNode() this.base = BTNode; if ( arguments.length == 0 ) this.base(); else if ( arguments.length == 1 ) this.base( arguments[ 0 ] ); else var temp = this.initialize( arguments ); this.base( temp.data, temp.leftchild, temp.rightchild ); BSTNode.prototype = new BTNode; function BSTNode_insert( val ) if ( val < this.data ) if ( this.leftchild == null ) this.leftchild = new BSTNode( val ); else this.leftchild.insert( val ); else if ( this.rightchild == null ) this.rightchild = new BSTNode( val ); else this.rightchild.insert( val ); function BSTNode_initialize( args ) var root = new BSTNode( args[ 0 ] ); for ( var i = 1; i < args.length; i++ ) root.insert( args[ i ] ); return root; BSTNode.prototype.insert = BSTNode_insert; BSTNode.prototype.initialize = BSTNode_initialize; 188

14 The test file constructs three binary search trees: bst1 is empty, bst2 contains the single value 5, and bst3 is initialized with the sequence 5, 3, 7, 1, 9. It then confirms that bst1 has undefined as the data value in its sole node. Then it outputs the data value (5) in the only node in bst2. Next, it outputs the inorder traversal of bst3. Since bst3 is as shown on the right, this gives Next, it inserts 6 into bst3, putting it as the left child of 7. Another inorder traversal produces

15 The test file is: var bst1 = new BSTNode(), bst2 = new BSTNode( 5 ); bst3 = new BSTNode( 5, 3, 7, 1, 9 ); if ( bst1.getdata() == undefined ) document.writeln( "<p>bst1.getdata() returns undefined</p>" ); document.writeln( "<p>bst2.getdata(): " + bst2.getdata() + "</p>" ); document.write( "bst3.inordertraversal():<br>" ); bst3.inordertraversal(); bst3.insert( 6 ); document.write( "<br>bst3.inordertraversal():<br>" ); bst3.inordertraversal(); The following is the HTML file that executes these files. btnode.js defines BTNode. bstnode.js defines BSTNode. testbstnode.js contains the test code. <html> <head> <title>tests</title> <script type = "text/javascript" src = "btnode.js"> </script> <script type = "text/javascript" src = "bstnode.js"> </script> <script type = "text/javascript" src = "testbstnode.js"> </script> </head> </html> 190

16 The following is the rendering: bst1.getdata() returns undefined bst2.getdata(): 5 bst3.inordertraversal(): bst3.inordertraversal():

Binary Trees, Binary Search Trees

Binary Trees, Binary Search Trees Trees Linear access time of linked lists is prohibitive Does there exist any simple data structure for which the running time of most operations (search, insert, delete)