Java 如何计算二叉搜索树中的非叶节点数？

我正在用我的代码发布新问题。我试图计算二叉搜索树的非叶节点。我正在创建非叶方法，然后尝试在测试类中调用它。有人能帮我吗？代码如下：

public class BST {
    private Node<Integer> root;

    public BST() {
        root = null;
    }

    public boolean insert(Integer i) {
        Node<Integer> parent = root, child = root;
        boolean gLeft = false;

        while (child != null && i.compareTo(child.data) != 0) {
            parent = child;
            if (i.compareTo(child.data) < 0) {
                child = child.left;
                gLeft = true;
            } else {
                child = child.right;
                gLeft = false;
            }
        }

        if (child != null)
            return false;
        else {
            Node<Integer> leaf = new Node<Integer>(i);
            if (parent == null)
                root = leaf;
            else if (gLeft)
                parent.left = leaf;
            else
                parent.right = leaf;
            return true;
        }
    }

    public boolean find(Integer i) {
        Node<Integer> n = root;
        boolean found = false;

        while (n != null && !found) {
            int comp = i.compareTo(n.data);
            if (comp == 0)
                found = true;
            else if (comp < 0)
                n = n.left;
            else
                n = n.right;
        }

        return found;
    }

    public int nonleaf() {
        int count = 0;
        Node<Integer> parent = root;

        if (parent == null)
            return 0;
        if (parent.left == null && parent.right == null)
            return 1;
    }

}

class Node<T> {
    T data;
    Node<T> left, right;

    Node(T o) {
        data = o;
        left = right = null;
    }
}

公共类BST{
私有节点根；
公共BST（）{
root=null；
}
公共布尔插入（整数i）{
节点父节点=根节点，子节点=根节点；
布尔gLeft=false；
while（child！=null&&i.compareTo（child.data）！=0）{
父母=子女；
if（i.compareTo（子数据）<0）{
child=child.left；
gLeft=真；
}否则{
child=child.right；
gLeft=假；
}
}
if（child！=null）
返回false；
否则{
节点叶=新节点（i）；
如果（父项==null）
根=叶；
否则如果（gLeft）
parent.left=叶；
其他的
parent.right=叶；
返回true；
}
}
公共布尔查找（整数i）{
节点n=根；
布尔值=false；
while（n！=null&&！找到）{
int comp=i.比较（n.数据）；
如果（comp==0）
发现=真；
否则如果（组件<0）
n=n.左；
其他的
n=n.对；
}
发现退货；
}
公共int nonleaf（）{
整数计数=0；
节点父节点=根节点；
如果（父项==null）
返回0；
if（parent.left==null&&parent.right==null）
返回1；
}
}
类节点{
T数据；
左、右淋巴结；
节点（TO）{
数据=o；
左=右=空；
}
}

如果只对非叶节点的计数感兴趣，则可以遍历树一次并保持一个计数。每当您遇到一个节点，使其具有左或右节点增量计数。

您可以使用以下函数来计算二叉树的非叶节点数

int countNonLeafNodes(Node root)
{ 
    if (root == null || (root.left == null &&  
                         root.right == null)) 
        return 0; 
    return 1 + countNonLeafNodes(root.left) +  
               countNonLeafNodes(root.right); 
}

---

我如何做到这一点？使用inorder或任何标准的树遍历技术。这将帮助您：