What is the big O of this method?

Is this implementation O(s + log(n)) where s = the number of items returned by the iterator and n = the total number of nodes in the tree? If not, would defining keysInRange helper recursively make a difference?

@Override
public Iterator<T> keysInRange(T start, T end) {
    List<T> list = keysInRangeHelper(root, start, end);
    Iterator<T> iter = list.iterator();

    return iter;

}



private List<T> keysInRangeHelper(TreeNode<T> root, T start, T end){
    if(root == null){
        return null;
    }

    LinkedList<TreeNode<T>> l = new LinkedList<>();
    l.add(root);
    List<T> result = new LinkedList<>();

    TreeNode<T> Node = root;

    while(!l.isEmpty()){
        Node = l.pop();
        if(Node.data.compareTo(start)>= 0 && Node.data.compareTo(end) < 0){
            result.add(Node.data);
        }
        if(Node.right != null){
            l.add(Node.right);
        }
        if(Node.left != null){
            l.add(Node.left);

        }
                }

        Collections.sort(result);
        return result;
    }