二叉树的大小与非递归Java方法

您好，我正在尝试编写一个非递归方法来获取节点的大小，因为Java中的递归非常昂贵。这将包括子节点数+1（本身）。我已经将一个C实现转换为Java，但它不正确

编辑：非递归计算二叉树大小的算法

public int size(Node n) {
    Stack<Node> sizeStack = new Stack();
    int count = 1;//includes the n node
    if(n == null) {
        return 0;
    }
    sizeStack.push(n);
    while(!sizeStack.isEmpty()){
        node = sizeStack.pop();
        while(node != null) {
            count++;
            if(node.right != null){
                sizeStack.push(node.right);
            }
            node = node.left;
        }
    }
    return count;
}

public int size（节点n）{
堆栈大小堆栈=新堆栈（）；
int count=1；//包括n个节点
如果（n==null）{
返回0；
}
sizeStack.push（n）；
而（！sizeStack.isEmpty（））{
node=sizeStack.pop（）；
while（节点！=null）{
计数++；
if（node.right！=null）{
sizeStack.push（node.right）；
}
node=node.left；
}
}
返回计数；
}

您的算法正在计算叶节点。您自己的愿望是计算所有节点。计算叶节点的算法只会在弹出叶节点时添加到计数器中，这对于Java和C都是如此。因此，实际上您的程序是好的，但对于您定义的问题不是这样

为了计算所有节点，每次从堆栈中弹出一个节点时都必须增加计数器。这意味着您必须推送所有节点，而不是像叶节点那样循环

如果您想保存推送操作（这是此算法优于递归的唯一原因，除非树向右不平衡），您应该只增加正在检查的每个节点的计数器，但保持基本循环不变

public int size(Node n) {
    Stack<Node> sizeStack = new Stack();
    int count = 1;//includes the n node
    if(n == null) {
        return 0;
    }
    sizeStack.push(n);
    while(!sizeStack.isEmpty()){
        node = sizeStack.pop();
        while(node != null) {
            count++;
            if(node.right != null){
                sizeStack.push(node.right);
            }
            node = node.left;
        }
    }
    return count;
}

public int size（节点n）{
堆栈大小堆栈=新堆栈（）；
int count=1；//包括n个节点
如果（n==null）{
返回0；
}
sizeStack.push（n）；
而（！sizeStack.isEmpty（））{
node=sizeStack.pop（）；
while（节点！=null）{
计数++；
if（node.right！=null）{
sizeStack.push（node.right）；
}
node=node.left；
}
}
返回计数；
}

这里是一个C实现。Real怀疑论者上面的方法对我来说不是那么直观。我提供评论，应该很容易理解

int sizeOfBsTree_nonRec(TreeNode *root)
{
    if (root == NULL) {
        return 0;
    }

    int size = 0;
    Stack S;
    initializeStack(&S);

    // Push to the stack all Nodes in the (sub)tree and
    // increase the counter when you pop one out
    push(root, &S);
    while(!isStackEmpty(&S)){
        root = pop(&S);
        size++;

        if (root->right != NULL)
            push(root->right, &S);
        if (root->left != NULL)
            push(root->left, &S);
    }

    return size;
}

---

很好的解决方案，但是在测试了实现之后，它并没有比递归更快。可能不会，因为您认为Java递归会很昂贵的假设并不一定正确。