# Counting Nodes in a Binary Tree

### Count All Nodes in Binary Tree :

```c
int countAllNodes(struct Node *ptr) {

    // Variables to obtain nodes is left and right subtree
    int leftNodes, rightNodes;
    
    if (ptr) {
        leftNodes = countAllNodes(ptr -> left);
        rightNodes = countAllNodes(ptr -> right);
        return leftNodes + rightNodes + 1;
    }
    return 0;

}
```

### Count Nodes Having Both Children (Degree 2) :

```c
int countTwoChildren(struct Node *ptr) {

    // Variables to obtain nodes is left and right subtree
    int leftNodes, rightNodes;
    
    if (ptr) {
        leftNodes = countTwoChildren(ptr -> left);
        rightNodes = countTwoChildren(ptr -> right);
        // Check if both children are present
        if (ptr -> left && ptr -> right) {
            return leftNodes + rightNodes + 1;
        } else {
            return leftNodes + rightNodes;
        }
    }
    return 0;

}
```

### Count Nodes Having One or More Children (Degree 1 or 2) :

```c
int countOneOrMore(struct Node *ptr) {

    // Variables to obtain nodes is left and right subtree
    int leftNodes, rightNodes;
    
    if (ptr) {
        leftNodes = countOneOrMore(ptr -> left);
        rightNodes = countOneOrMore(ptr -> right);
        // Check if atleast one child is present
        if (ptr -> left || ptr -> right) {
            return leftNodes + rightNodes + 1;
        } else {
            return leftNodes + rightNodes;
        }
    }
    return 0;

}
```

### Count Nodes Having Exactly One Child (Degree 1) :

```c
int countOneChild(struct Node *ptr) {

    // Variables to obtain nodes is left and right subtree
    int leftNodes, rightNodes;
    
    if (ptr) {
        leftNodes = countOneChild(ptr -> left);
        rightNodes = countOneChild(ptr -> right);
        // Perform XOR operation to check if only child is present
        if (ptr -> left ^ ptr -> right) {
            return leftNodes + rightNodes + 1;
        } else {
            return leftNodes + rightNodes;
        }
    }
    return 0;

}
```

### Count Leaf Nodes (Degree 0) :

```c
int countLeafNodes(struct Node *ptr) {

    // Variables to obtain nodes is left and right subtree
    int leftNodes, rightNodes;
    
    if (ptr) {
        leftNodes = countLeafNodes(ptr -> left);
        rightNodes = countLeafNodes(ptr -> right);
        // Check if both children are NULL
        if (!(ptr -> left) && !(ptr -> right)) {
            return leftNodes + rightNodes + 1;
        } else {
            return leftNodes + rightNodes;
        }
    }
    return 0;

}
```

### Alternative Way of Counting (Without Variables) :

```c
int count(struct Node *ptr) {

    if (ptr == NULL) {
        return 0;
    } 
    return count(ptr -> left) + count(ptr -> right) + 1;

}
```

Following the same style for all the other conditions.

Contributed by Nitin Ranganath


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://nitinranganath.gitbook.io/data-structures/binary-tree/counting-nodes-in-a-binary-tree.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.