Question

我想计算叶节点的数量：注意：不能使用全局/类级别变量我发现跟随算法，它工作正常。但我希望方法签名是

countLeaves(Node node)

我知道我可以重载methds并从1 args调用2 args方法sig，但不想这样做。任何人都可以建议任何其他方法吗？

int countLeaves(Node node,int count){
        if(node==null)
            return 0;

        if(node.left==null && node.right==null){
            return 1+count;
        }else{
            int lc = countLeaves(node.left, count);
            int total = countLeaves(node.right, lc);
            return total;
        }
    }

Answer 1

int countLeaves(Node node){
  if( node == null )
    return 0;
  if( node.left == null && node.right == null ) {
    return 1;
  } else {
    return countLeaves(node.left) + countLeaves(node.right);
  }
}

你正在做与以前相同的事情，但我们只是说返回左右节点之和的结果，而不是保持当前计数。这些反过来一直下降，直到它们击中基地。

Answer 2

您无需将count传递给调用堆栈，只需从：

开始

int countLeaves(Node node)
{
    if(node==null) {
        return 0;
    }
    if(node.left==null && node.right==null) {
        return 1;
    }
    return countLeaves(node.left) + countLeaves(node.right);
}

Answer 3

我们可以应用两种方法，一种是递归，另一种是迭代（基于队列的实现）。我将解释这两种方法。

递归解决方案

int count_leaf(Node node)
{
 if(node==NULL)
  return 0;
  if(node->left==NULL && node->right==NULL)
  return 1;
   return count_leaf(node->left)+count_leaf(node->right);
}

第二种方法是迭代（基于队列的实现），想法取自树的级别顺序遍历。

int count_leaf(Node root)
{
int count=0;
  if(root==NULL)
    return 0;

  queue<Node *> myqueue;
  myqueue.push(root);

  while(!myqueue.empty())
{
  Node temp;
   temp=myqueue.top();   //Take the front element of queue 
   myqueue.pop();        //remove the front element of queue
  if(temp->left==NULL && temp->right==NULL)
   count++;
   if(temp->left)
    myqueue.push(temp->left);
   if(temp->right)
   myqueue.push(temp->right);
}
return count;
}

我希望这些解决方案能为您提供帮助。

Answer 4

自己填写???部分。

int countLeaves(Node node){
    if (node==null)
        return 0;

    if (node.left==null && node.right==null){
        return 1;
    } else {
        int lc = countLeaves(node.left);
        int rc = countLeaves(node.right);
        return ???;
    }
}

Answer 5

由于我仍在对此实现进行单元测试，因此不会做出无错误操作的承诺。如果实施存在特殊问题，我很高兴收到反馈意见。

最初，我收到了有利的结果：

#region CountNode utility
private int CountNode(Node node, Direction d) {
    Func<Direction, Node> leaf = (dir) => {
        return dir == Direction.Left ? node.Left : node.Right;
    };

    var done = leaf(d) == null;
    var root = node;
    var stack = new Stack<Node>( );
    var count = 0;

    while(!done) {
        if (node != null) {
            stack.Push(node);
            node = leaf(d);
        }
        else {
            if(stack.Count > 0) {
                node = stack.Pop( );
                //  back to root, time to quit
                if(node == root) {
                    done = true;
                    continue;
                }

                //  count nodes when popped
                ++count;

                //  flip direction
                var flip = d == Direction.Left ? Direction.Right : Direction.Left;
                //  get the leaf node
                node = leaf(flip);
            }
            else {
                done = true;
            }
        }
    }

    return count;
}
#endregion

用法：

var actLeftCount = CountNode(root, Direction.Left);
var actRightCount = CountNode(root, Direction.Right);

这具有仅计算Left上的节点的特殊优势。我可以将任何节点传递给方法并接收相同的统计信息。

Answer 6

public int getLeafsCount(BSTNode<T> node, int count) {
    if(node == null || node.getData() == null){
        return count;
    }
    else if(isLeaf(node)){
        return ++count;
    }else{  
        int leafsLeft =  getLeafsCount((BSTNode<T>) node.getLeft(), count);
        int leafsCount = getLeafsCount((BSTNode<T>) node.getRight(), leafsLeft);

        return leafsCount;
    }

}

计算二叉树中叶节点的数量

6 个答案: