Question

我要在几个小时内学习考试，并且要解决一些练习问题，但是我确实遇到了与递归相关的问题。我想知道是否有人可以指导我完成这些操作？

使用下面的BinaryTree class，创建以下recursive方法：

sum() –返回BinaryTree中所有值的总和。
countGreaterThan(int) –返回值大于指定整数的节点数。
isValidSearchTree() –如果二叉树是有效的搜索树，则返回true，否则返回false。

我了解了如何创建这些函数的基本前提，例如，对于sum函数，通常会这样：

int sum = 0
for(int i; i<binaryTree.size(); i++){
    sum += binaryTree[i]
}

或类似的东西。但是我真的不知道如何将这些概念与BinaryTree一起应用于nodes并使其也recursive吗？我提供的代码如下。

public class BinaryTree {
 private int data;
 private BinaryTree leftChild;
 private BinaryTree rightChild;

 public BinaryTree(int val) {
     data = val;
     leftChild = null;
     rightChild = null;
  }

  // Get methods
 public int getData() { return data; }
 public BinaryTree getLeftChild() { return leftChild; }
 public BinaryTree getRightChild() { return rightChild; }

 // Set methods
 public void setData(int val) { data = val; }
 public void setLeftChild(BinaryTree left) { leftChild = left; }
 public void setRightChild(BinaryTree right) { rightChild = right; }
}

Answer 1

您应该研究recursion的功效，但是我已经编码了您所要求的方法，所有这些方法都像魅力一样发挥作用：

/*
* INPUT:   Root node
* OUTPUT:  Sum of the data of all nodes of tree
*/

public void sum(TreeNode node)
{
    if(node == null)
        return;

    sum(node.leftNode);  // recursive call to left subtree of each node
    sum += node.data;
    sum(node.rightNode);  // recursive call to right subtree of each node
}


/*
* INPUT:   Root node , threshold value
* OUTPUT:  sum of all node's data, that rae greater than "value"
*/

public void countGreaterThan(TreeNode node, int value)
{
    if(node == null)
        return;

    countGreaterThan(node.leftNode,value);
    if( node.data > value)    // only adds is node.data is greater than given value 
        sum += node.data;
    countGreaterThan(node.rightNode,value);
}   

/*
* INPUT:  nothing
* OUTPUT:  call to its helper function, taking MIN, MAX, and root as input
*/

public boolean isBST()  
{ 
    return isBSThelper(root, Integer.MIN_VALUE,  Integer.MAX_VALUE); 
}   

public boolean isBSThelper(TreeNode node, int min, int max) 
{ 
    if (node == null)   //empty tree is always a BST 
        return true; 

    if (node.data < min || node.data > max) //if node breaks the min/max condition 
        return false; 

    // recursive call to left subtree and right subtree
    return (isBSThelper(node.leftNode, min, node.data-1) && isBSThelper(node.rightNode, node.data+1, max)); 
}

Answer 2

如果您可以对import numba print(numba.__file__)进行递归尝试，那么我将为您提供更多帮助。一旦您提供示例，我将使用更全面的信息来更新此答案。

作为一般提示，在处理递归和二叉树时：

将其绘制出来并找到可能的解决方案。这可以帮助您可视化所需的代码。
对于任何给定节点，您都想访问其所有子节点。这意味着如果它只有一个孩子（左或右），则您访问该孩子；如果有两个孩子（左和右），则您都访问该孩子；如果您没有任何孩子，则终止访问（这是一个很大的基本情况提示就在那里）。

Answer 3

首先，我认为您有太多问题，但是对于this meta discussion in mind，我将逐步介绍递归求和函数，并说明如何递归解决此类问题。

这些算法似乎都需要depth first search，因此，我建议您也检查链接的视频。

关于递归的整洁之处是使我们仅考虑每个特定节点必须做什么。对于sum的示例，这意味着返回其存储的值以及其子级的递归和。

public int exampleSum(){
   // Start with the data we have.
   int sum = this.getData();

   // Then get the data we need (from each child, which can be done recursively).
   if (this.getLeftChild() != null) {
       sum += this.getLeftChild().exampleSum();
   }
   // Do the same for the right node.

   return sum; 
}

这等同于遍历每个节点，并获取每个子树的总和。

想象一下，一群人站在一棵二叉树的形状中，每个人都有一个“父母”和0到2个“孩子”，并且每个人都有一个数字。

我们从顶部开始，而不是一个人询问每个人的电话号码并将其全部相加（循环），而是由第一个人向其子女询问其总和，然后由他们的子女询问其子女，等等（递归）。

每个人都将孩子给他们的号码加到他们的号码上，然后交给父母。

这两种特殊情况是当该人没有孩子时，他们停下来，将其号码交给父母，而“根”节点首先将其号码提供给任何要求他们使用的功能。

我建议绘制一个二叉搜索树，并亲自完成此算法。

我希望这会有所帮助，如果可以的话，您是否喜欢此答案。

将来，我建议一次问一个问题。祝您测试顺利！

给定BinaryTree创建递归方法

3 个答案: