Table of contents
Binary search tree node lookup
src/runoob/binary/BinarySearchTreeSearch.java file code:
Binary search tree node lookup
The binary search tree does not have subscripts, so for the search operation of the binary search tree, a contain method is defined here to determine whether the binary search tree contains a certain element and returns a Boolean variable. This search operation is also a recursive process. Specifically The code is implemented as follows:
...
// Check whether the binary search tree with node as the root contains a node with the key value, using the recursive algorithm
private boolean contain(Node node, Key key){ if( node == null ) return false; if( key.compareTo(node.key) == 0 ) return true; else if( key.compareTo(node.key) < 0 ) return contain( node.left , key ); else // key > node->key return contain ( node.right , key ); } ...
The following example finds 43 elements in a binary search tree
(1) The element 43 is larger than the root node 42, and the comparison needs to be continued at the right child node.
(2) Element 43 is smaller than 59, and the comparison needs to be continued at the left child node.
(3) Element 43 is smaller than 51, so comparison needs to continue at the left child node.
(4) Find the left child node 43 of 51, which is exactly equal to the sum, and end.
If you need to find the value corresponding to the key, the code is as follows:
...
// Find the value corresponding to the key in the binary search tree with node as the root, recursive algorithm
// If the value does not exist, return NULL
private Value search(Node node, Key key){ if( node == null ) return null; if( key.compareTo(node.key) == 0 ) return node.value; else if( key.compareTo(node.key) < 0 ) return search( node.left , key ); else / / key > node->key return search( node.right, key ); } ...
Java example code
Source code package download: Download 
https://www.runoob.com/wp-content/uploads/2020/09/runoob-algorithm-BinarySearchTreeSearch.zip
src/runoob/binary/BinarySearchTreeSearch.java file code:
package runoob.binary;
/**
* Binary search tree search
*/
public class BinarySearchTreeSearch<Key extends Comparable<Key>, Value> { // The nodes in the tree are private classes, and the outside world does not need to know the details of the binary search tree nodes. Implement private class Node { private Key key; private Value value; private Node left, right; public Node(Key key, Value value) { this.key = key; this.value = value; left = right = null; } } / / Root node private Node root; // Number of nodes in the tree species private int count; // Constructor, constructs an empty binary search tree by default public BinarySearchTreeSearch() {
root = null;
count = 0;
}
// Returns the number of nodes in the binary search tree
public int size() { return count; } // Returns whether the binary search tree is empty public boolean isEmpty() { return count == 0; } // Insert a new (key, value) data pair into the binary search tree public void insert(Key key, Value value){ root = insert(root, key, value); } // Check whether the binary search tree The key key exists public boolean contain(Key key){ return contain(root, key); } // Search the value corresponding to the key key in the binary search tree. If this value does not exist, null is returned public Value search(Key key){ return search(root, key);
}
//********************
//* Auxiliary function for binary search tree
//**************** ****
// Insert node (key, value) into the binary search tree with node as the root, using the recursive algorithm //
Return the root of the binary search tree after inserting the new node
private Node insert(Node node, Key key , Value value){ if( node == null ){ count ++; return new Node(key, value); } if( key.compareTo(node.key) == 0 ) node.value = value; else if( key.compareTo(node.key) < 0 ) node.left = insert( node.left , key, value); else // key > node->key node.right = insert( node.right, key, value); return node;
}
// Check whether the binary search tree with node as the root contains a node with the key value, using the recursive algorithm
private boolean contain(Node node, Key key){ if( node == null ) return false; if( key. compareTo(node.key) == 0 ) return true; else if( key.compareTo(node.key) < 0 ) return contain( node.left , key ); else // key > node->key return contain( node .right , key ); } // Find the value corresponding to key in the binary search tree with node as the root, recursive algorithm // If value does not exist, return NULL private Value search(Node node, Key key){ if ( node == null ) return null; if( key. compareTo(node. key) == 0 )
return node.value;
else if( key.compareTo(node.key) < 0 )
return search( node.left , key );
else // key > node->key
return search( node.right, key );
}
}