To solve this task, we need a way to determine the height of the left and right subtrees for every node and check if the difference is more than 1.

A naive approach would be to calculate the height of the left and right subtrees for each node separately. This would be inefficient, leading to a time complexity of O(n^2), as we would repeatedly calculate the height of the same subtrees.

A more efficient, O(n) approach is to combine the height calculation and the balance check into a single recursive traversal. We can define a helper function that returns two pieces of information for a given node:
1. Is the subtree rooted at this node balanced?
2. What is the height of this subtree?

We can optimize this by using a special return value (like -1) to signify that a subtree is unbalanced. If a subtree is balanced, the function returns its height (a non-negative integer).

The logic of this helper function for a given `node` would be:
1. **Base Case**: If the `node` is `None`, it's a balanced subtree with a height of 0.
2. **Recursive Step**:
   a. Recursively call the helper on the left child. If it returns -1, the left subtree is unbalanced, so we propagate -1 up.
   b. Do the same for the right child.
3. **Check Current Node**: If both subtrees are balanced, check the current node. If `abs(left_height - right_height) > 1`, the current node is unbalanced, so return -1.
4. **Return Height**: If the current node is balanced, return its height, which is `1 + max(left_height, right_height)`.

The main function will then call this helper on the root of the tree. If the result is -1, the tree is not balanced; otherwise, it is.

The provided function signature `__init__(self, data)` is a constructor for a class. This implies that the solution should be structured as a class, where each instance represents a node in the tree. The balance-checking logic can be implemented as a method of this class.

```python
def __init__(self, data):
    self.data = data
    self.left = None
    self.right = None

def is_balanced(self):
    """
    Checks if the binary tree rooted at this node is balanced.
    """
    def get_height_if_balanced(node):
        """
        Helper function to get the height of a node's subtree.
        Returns -1 if the subtree is unbalanced, otherwise returns its height.
        """
        # Base case: an empty tree is balanced and has height 0.
        if node is None:
            return 0

        # Recursively check the left subtree.
        left_height = get_height_if_balanced(node.left)
        # If the left subtree is unbalanced, propagate the unbalanced signal.
        if left_height == -1:
            return -1

        # Recursively check the right subtree.
        right_height = get_height_if_balanced(node.right)
        # If the right subtree is unbalanced, propagate the unbalanced signal.
        if right_height == -1:
            return -1

        # Check if the current node is balanced.
        if abs(left_height - right_height) > 1:
            return -1

        # If balanced, return the height of the subtree rooted at this node.
        return 1 + max(left_height, right_height)

    # The tree is balanced if the helper function does not return -1.
    # The check starts from the current node ('self').
    return get_height_if_balanced(self) != -1

```