根据子节点数确定二叉树中的节点数

Question

给你一个二叉树的根节点T。我们在 T 中区分三种类型的节点：具有 0 个子节点（即叶子）的节点、具有 1 个子节点的节点和具有两个子节点的节点。为每种类型确定T 中的节点总数。将结果作为长度为 3 的整数数组返回。

输出应该是一个包含上述所有类型节点计数的数组。

这是我拥有的，但在我运行它时没有通过我的导师的测试：

private static int[] problem1(Node root){

     int[] nodeCount = new int[]{0,0,0};

     // BASE CASE
     if (root == null) {

        // Implement me!
        return new int[] {
           -1, // nodes with 0 children
           -1, // nodes with 1 child
           -1  // nodes with 2 children
        };

     }

     // RECURSIVE CALL
     int[] leftChild = problem1(root.left);
     int[] rightChild = problem1(root.right);

     nodeCount[0] = leftChild[0] + rightChild[0];
     nodeCount[1] = leftChild[1] + rightChild[1];
     nodeCount[2] = leftChild[2] + rightChild[2];

     if(root.left != null && root.right != null) {

        nodeCount[2]++;
        problem1(root.left);
        problem1(root.right);

     }else if(root.left != null && root.right == null) {

        nodeCount[1]++;
        problem1(root.left);

     }else if(root.left == null && root.right != null) {

        nodeCount[1]++;
        problem1(root.right);

     }else {

        nodeCount[0]++;
     }

     return nodeCount;
}

Answer 1

您的代码的问题是每次调用空节点时数组的每个元素都是-1。此代码将给出正确答案：

private static int[] problem1(Node root){
    // Implement me!

    //initialize arrays
    int[] nodeCount = {0,0,0};
    int[] n1 = new int[3];
    int[] n2 = new int[3];

    //2 children case
    if(root.left != null && root.right != null){
        n1 = problem1(root.left);
        n2 = problem1(root.right);
        nodeCount[0] += n1[0] + n2[0];
        nodeCount[1] += n1[1] + n2[1];
        nodeCount[2] += n1[2] + n2[2];
        nodeCount[2]++;
        return nodeCount;           
    }

    //leaf case
    if(root.left == null && root.right == null){
        return new int[] {1,0,0};
    }

    //only right child 
    if (root.left == null && root.right != null){
        n1 = problem1(root.right);
        nodeCount[0] += n1[0];
        nodeCount[1] += n1[1];
        nodeCount[2] += n1[2];
        nodeCount[1]++;
        return nodeCount;
    }

    //only left child
    if (root.left != null && root.right == null){
        n1 = problem1(root.left);
        nodeCount[0] += n1[0];
        nodeCount[1] += n1[1];
        nodeCount[2] += n1[2];
        nodeCount[1]++;
        return nodeCount;
    }

   //should never run unless null node is given at start  
   else{
       return new int[] {
           -1, // nodes with 0 children
           -1, // nodes with 1 child
           -1  // nodes with 2 children
       };
    }
}

Answer 2

我正在写粗略的代码，请检查它是否解决了您的问题：

    HashMap<Integer, Integer> count = new HashMap<>();

    // For now, 0 key having a count of leaf nodes, 1 key count of nodes having a single child, 2 for both 
    // Use inorder, pre or post to traverse the tree... use countNodes to get count
    // I have used hashmap to keep count, you can take an array as well.

   public void inorder(TreeNode root){
       if(root == null) return;
       inorder(root.left);
       countNodes(root);
      inorder(root.right);
    }

  public void countNodes(TreeNode root){
       if(root == null) return;
       else if(root.left != null && root.right != null){
         count.put(2, 1 + count.getOrDefault(2,0));
       } 
      else if(root.left == null && root.right == null){
         count.put(0, 1 + count.getOrDefault(0,0));
       } 
      else{
         count.put(1, 1 + count.getOrDefault(1,0));
      } 
    }