Algorithm 二叉搜索树中的Floor实现

考虑一下Robert Sedgewick在他的：

如果给定的键小于BST根的键，则键的楼层（BST中最大的键小于或等于键）必须位于左子树中。如果key大于根上的key，则key的底可以在右子树中，但只有当右子树中有一个key小于或等于key时；如果不是（或者如果关键点与根处的关键点相等），则根处的关键点是关键点的地板。 我非常困惑当键大于根时会发生什么，特别是当他说：“但只有当右子树中有一个键小于或等于键时”。我想他的意思是，如果键小于根，那么键肯定在左子树中。另一方面，如果密钥是grater，则密钥“可能”在右子树中，因此也可能在右子树上找不到密钥。根据他的floor（）方法：

公钥楼层（钥匙）
{
节点x=楼层（根，键）；
如果（x==null）返回null；
返回x.key；
}
专用节点楼层（节点x，密钥）
{
如果（x==null）返回null；
int cmp=键。比较（x.key）；
如果（cmp==0）返回x；
如果（cmp<0）返回地板（x左键）；
节点t=地板（x.右侧，键）；
如果（t！=null）返回t；
否则返回x；
}

他确实检查了右子树，但没有检查左子树。但我完全不能给出一个例子，其中键大于根，但小于右子树中的键。我真的认为这是不可能的。我错过了一些东西。有人能解释我遗漏了什么吗？

如果你有一棵树（请原谅我的ASCII艺术技能）

那么你要找的是第（4）层

搜索键大于根

右子树中没有比搜索键小的键，因此

结果是根键（3）

如果你有一棵树（请原谅我的ASCII艺术技巧）

那么你要找的是第（4）层

搜索键大于根

右子树中没有比搜索键小的键，因此

结果是根键（3）

如果你有一棵树（请原谅我的ASCII艺术技巧）

那么你要找的是第（4）层

搜索键大于根

右子树中没有比搜索键小的键，因此

结果是根键（3）

如果你有一棵树（请原谅我的ASCII艺术技巧）

那么你要找的是第（4）层

搜索键大于根

右子树中没有比搜索键小的键，因此

结果是根键（3）

一个简单的解决方案：

            int FloorInBST(Node* root,int data)
            {
              if(root == NULL)
              {
                  return -1;//when MinNode of tree is greater than the input value
              }
              if(root->data == data) return data;

              if(root->data > data)
              {
                  return FloorInBST(root->left, data);//MUST be in left subtree 
              }
              else if (root->data < data)
              {
                  //MAY be in right subtree OR root itself
                  int floor = FloorInBST(root->right, data);
                  return (root->data >= floor ? root->data:floor);
              }
            }

int FloorInBST（节点*根，int数据）
{
if（root==NULL）
{
return-1；//当树的MinNode大于输入值时
}
如果（根->数据==数据）返回数据；
如果（根->数据>数据）
{
return FloorInBST（root->left，data）；//必须在左子树中
}
else if（根->数据<数据）
{
//可能在右子树或根本身中
intfloor=FloorInBST（根->右，数据）；
返回（根->数据>=楼层？根->数据：楼层）；
}
}

一个简单的解决方案：

            int FloorInBST(Node* root,int data)
            {
              if(root == NULL)
              {
                  return -1;//when MinNode of tree is greater than the input value
              }
              if(root->data == data) return data;

              if(root->data > data)
              {
                  return FloorInBST(root->left, data);//MUST be in left subtree 
              }
              else if (root->data < data)
              {
                  //MAY be in right subtree OR root itself
                  int floor = FloorInBST(root->right, data);
                  return (root->data >= floor ? root->data:floor);
              }
            }

int FloorInBST（节点*根，int数据）
{
if（root==NULL）
{
return-1；//当树的MinNode大于输入值时
}
如果（根->数据==数据）返回数据；
如果（根->数据>数据）
{
return FloorInBST（root->left，data）；//必须在左子树中
}
else if（根->数据<数据）
{
//可能在右子树或根本身中
intfloor=FloorInBST（根->右，数据）；
返回（根->数据>=楼层？根->数据：楼层）；
}
}

一个简单的解决方案：

            int FloorInBST(Node* root,int data)
            {
              if(root == NULL)
              {
                  return -1;//when MinNode of tree is greater than the input value
              }
              if(root->data == data) return data;

              if(root->data > data)
              {
                  return FloorInBST(root->left, data);//MUST be in left subtree 
              }
              else if (root->data < data)
              {
                  //MAY be in right subtree OR root itself
                  int floor = FloorInBST(root->right, data);
                  return (root->data >= floor ? root->data:floor);
              }
            }

int FloorInBST（节点*根，int数据）
{
if（root==NULL）
{
return-1；//当树的MinNode大于输入值时
}
如果（根->数据==数据）返回数据；
如果（根->数据>数据）
{
return FloorInBST（root->left，data）；//必须在左子树中
}
else if（根->数据<数据）
{
//可能在右子树或根本身中
intfloor=FloorInBST（根->右，数据）；
返回（根->数据>=楼层？根->数据：楼层）；
}
}

一个简单的解决方案：

            int FloorInBST(Node* root,int data)
            {
              if(root == NULL)
              {
                  return -1;//when MinNode of tree is greater than the input value
              }
              if(root->data == data) return data;

              if(root->data > data)
              {
                  return FloorInBST(root->left, data);//MUST be in left subtree 
              }
              else if (root->data < data)
              {
                  //MAY be in right subtree OR root itself
                  int floor = FloorInBST(root->right, data);
                  return (root->data >= floor ? root->data:floor);
              }
            }

int FloorInBST（节点*根，int数据）
{
if（root==NULL）
{
return-1；//当树的MinNode大于输入值时
}
如果（根->数据==数据）返回数据；
如果（根->数据>数据）
{
return FloorInBST（root->left，data）；//必须在左子树中
}
else if（根->数据<数据）
{
//可能在右子树或根本身中
intfloor=FloorInBST（根->右，数据）；
返回（根->数据>=楼层？根->数据：楼层）；
}
}