1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

class BSTNode {
	private:
		ElementType element; // element stored in tree node
		int leftChild; // index to left child/subtree
		int rightChild; // index to right child/subtree
}

class BinarySearchTree {
	private:
		BSTNode myTree[CAPACITY];// array of tree elements
		int root; // index of root
		int elementCount; // number of elements
}

1
2
3
4
5

class BinarySearchTree {
	private:
		ElementType myTree[CAPACITY]; // array of elements
		int elementCount; // number of elements
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class BSTNode { 
	private:
		ElementType element; // element stored in tree
		node BSTNode* leftChild; // link to left child/subtree
		BSTNode* rightChild; // link to right child/subtree 
}

class BinarySearchTree {
	private:
		BSTNode* root; // root of tree
		int elementCount; // number of elements
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

Node* BST::insertR(Node* subTree, Node* newNode){
	if (subTree == NULL) return newNode; // Base case
	else
	{
		if (subTree→getElement() > newNode→getElement())
		subTree→setLeft(insertR(subTree→getLeft(), newNode));
		else
		subTree→setRight(insertR(subTree→getRight(),newNode));
	return subTree;
} // end if
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

BTnode_t* recursive_find (BTnode_t* root, int item) {
	if ( root == NULL )
		return NULL;
	if (root→value == item)
		return root;
	if ( root→value > item )
		return find( root→left, item) ;
	else // if ( root→data < item )
		return find( root→right, item) ;
}


BTnode_t* iterative_find (BTnode_t* root, int item) {
 BTnode_t* current = root;
	while ( current != NULL && current→value != item) {
		if (current→value > item )
			 current = current→left;
		else  	// current→data < item
			current = current→right;
	}
	return current;
}

1

list from Binary Search Trees AND !outgoing(Binary Search Trees)