Code smell when recursively returning a List
I wouldn't say there is a code smell with what you have now. However, it could be made more OOP-friendly.

An actual problem is that you're using raw types for Node, and that is never a good idea. So, first of all, consider having this instead:

private List&lt;T&gt; getInfix() {
    List&lt;T&gt; result = new ArrayList&lt;&gt;();
    getInfixInternal(root, result);
    return result;
}

private void getInfixInternal(Node&lt;T&gt; node, List&lt;T&gt; infixValues) {
    if (node != null) {
        getInfixInternal(node.getLeft(), infixValues);
        infixValues.add(node.getValue());
        getInfixInternal(node.getRight(), infixValues);
    }
}


and

public class Node&lt;T extends Comparable&lt;? super T&gt;&gt;


Then, to avoid this getInfixInternal, you can reason with what the method getInfix means. The first thing to realize is that it works on a given Node. In fact, it is really a property of the node itself: every node can return a list of values resulting of a infix traversal of the subtree starting at this node. Therefore, instead of having an internal method taking a Node as parameter, make it a method of Node:

public class Node&lt;T extends Comparable&lt;? super T&gt;&gt; {

    // ...

    public List&lt;T&gt; getInfix() {
        List&lt;T&gt; result = new ArrayList&lt;&gt;();
        if (leftChild != null) {
            result.addAll(leftChild.getInfix());
        }
        result.add(value);
        if (rightChild != null) {
            result.addAll(rightChild.getInfix());
        }
        return result;
    }

}


With such a method, you can then have:

private List&lt;T&gt; getInfix() {
    return root == null ? Collections.emptyList() : root.getInfix();
}


With Java 8 Optional, you could potentially write that more concisely:

public List&lt;T&gt; getInfix() {
    List&lt;T&gt; result = new ArrayList&lt;&gt;();
    Optional.ofNullable(leftChild).map(Node::getInfix).ifPresent(result::addAll);
    result.add(value);
    Optional.ofNullable(rightChild).map(Node::getInfix).ifPresent(result::addAll);
    return result;
}


Final note: you could also consider returning unmodifiable lists.