Give an algorithm for a function int largest (TreeNode *tree) that takes a pointer to a root of a binary search tree as parameter and returns the largest value stored in the tree.

We start by writing the function signature as given in the problem statement: ```cpp int largest (TreeNode *tree); ``` The function `largest` takes a pointer to the root node of a binary search tree as an argument and returns an integer which is the largest value in the tree.

In this step, we will implement the algorithm iteratively. We start from the root node and follow the right subtree until we find a node with no right child: ```cpp int largest (TreeNode *tree) { TreeNode *current_node = tree; while (current_node->right != nullptr) { current_node = current_node->right; } return current_node->value; } ``` In this implementation, we initialize a pointer `current_node` that initially points to the root of the tree. Then, we use a while loop to traverse the tree from the root to the node with the largest value. Inside the loop, we check if the right child of the current node is not `nullptr`. If so, we update the `current_node` pointer to point to its right child. We continue doing this until we reach a node with no right child. Finally, we return the value of the node containing the largest value.

Alternatively, we can solve this problem using a recursive approach. We will call the function recursively if the right child of the current node exists, otherwise, we will return the value of the current node: ```cpp int largest (TreeNode *tree) { if (tree->right == nullptr) { return tree->value; } return largest(tree->right); } ``` In this implementation, we check if the right child of the current node is `nullptr`. If so, we return the value of the current node since it contains the largest value in the tree. Otherwise, we call the `largest` function recursively with the right child of the current node as its argument.