二叉搜索树中具有最小值的节点

Question

I would like to find the most efficent way to check the node with minimum value in a Binary Search Tree. I'm not thinking to do it in a certain programming language right now, I would like just to think the most efficent algorithm.

What do you think about this:

procedure minBST(t)
if (t = NULL) then return; 
if (t -> left = NULL) then return  t -> inf;  
 *// if the left node is null, then in a BST the smallest value will be the root*
if (t -> left != NULL) then .... 
 *// I need to dig more in the left side until I get the last left node*

My question is how should I dig deeper until I get the last left node. Also I tried to explain the steps. Do you think that is the best way to do it?

Answer 1

If you have a proper BST you can continue going down the left child:

     10
   /    \
  5      12
 / \    /  \
1   6  11  14

If a node does not have a left child (Null) you know the node you're currently in has the minimum value. The easiest approach is via recursion:

int minBST(TreeNode node)
{
  if (node->left == Null)
    return node->value;
  else
    return minBST(node->left);
}

To start the search simply call the function above with the root as node parameter. The tree above will have a code path as follows:

• minBST(node with value 10) -> has left child -> minBST(node with value 5)
• minBST(node with value 5) -> has left child -> minBST(node with value 1)
• minBST(node with value 1) -> has no left child -> return 1

If your tree contains n nodes and is balanced (equal depth everywhere) this will take O(log_2 n) operations and is the fastest approach without additional bookkeeping. The fact that the tree is balanced is important to get the best performance, if you want to maintain your tree balanced have a look at red-black trees.

Answer 2

The following code should do the job:

node* FindMin(node* n)
{
    if(n == NULL)
        return NULL;

    if(n->left == NULL)
        return n;

    while(n->left != NULL)
    {
        n = n->left;
    }

    return n;
}

The complexity is O(log(n)), that the best you can get assuming the tree is balanced.

Answer 3

    public int MinValue(TreeNode root)
    {
        if (root == null)
        {
            return -1;
        }

        TreeNode node = root;
        while (node.Left != null)
        {
            node = node.Left;
        }

        return node.Value;
    }

https://codestandard.net/articles/min-value-binary-search-tree