Can a data structure have O(1) access time without using any arrays?

I think if you're following the spirit of the rules, then you provably can't do better than O(log n) time to get or set an element. The reason for this is that every object you instantiate can store at most a fixed number of data items and a fixed number of references to other objects, defined by how many fields that object has.

Let D be the (maximum) number of data items an object holds, and F be the (maximum) number of reference fields an object holds. To be clear, D counts the fields used to store the actual "array" data, and F counts the fields which are used for the data structure itself.

If your access times are O(1) then you can follow at most O(1) references to access the cell, which means your "array" size is limited to O(D * F^R) where R is a fixed limit on the number of references you're allowed to follow to fulfil one operation. If all three of D, F and R are constant, then so is the size of your "array". It follows that emulating the performance characteristics of an arbitrary-sized array data structure is impossible given the constraints.

This argument can be extended a little bit further to prove that R must be at least O(log n) in order to reach n distinct data items; i.e. that you must follow at least O(log n) references to access an item. You can use a complete binary tree to actually achieve this bound.

That said, there is at least one way to follow the letter of the rules without following the spirit of them.

You are strictly forbidden from using arrays or JCF library classes, but the only rules about third-party library classes are that you aren't allowed to import them or refer to them by a fully-qualified name. You could use the ClassLoader.loadClass method to load a collection class from a third-party library, instantiate it by reflection, assign it to a variable of type Object, and then call its methods by reflection. This is technically allowed because loadClass takes the "binary name", not the "fully qualified name" of the class you want to load. (I'll leave it to the lawyers to argue whether you would need to load a class whose binary name isn't also a fully qualified name.)

For the pedants: I interpret the rule about arrays as saying you must have no arrays in your code (except, presumably, String[] args in the main method), not no arrays in other people's code that your code calls; otherwise e.g. your program is forbidden from printing any output because data written to System.out gets buffered in an array. I think it is unlikely the rule is intended to forbid printing any output.

Without any addressable space, this leaves you with a tree structure, where each node holds a potential value and a number of children. One child per node would make it a linked list, two children a binary tree, and the more children per node you allow the faster the access becomes - eventually O(1) when the number of children per node fits or exceeds the array size.

The operations for an array are:

• initialize with an initial number of slots
• get length of array
• get element at index
• set element at index

I came up with following solution (binary tree, package and public modifier on methods omitted as requested, which makes it usable only from within the default package):

public class Array<T> {

    private final int length;
    private final Cell<T> root = new Cell<>();

    Array(int length) {
        if (length < 0) {
            throw new IllegalArgumentException("Array length must be >=0")
        }
        this.length = length;
    }

    T get(int index) {
        return cell(index).value;
    }

    void set(int index, T value) {
        cell(index).value = value;
    }

    int length() {
        return length;
    }

    private Cell<T> cell(int index) {
        if (index < 0 || index >= length) {
            throw new ArrayIndexOutOfBoundsException(index);
        }
        Cell<T> pointer = root;
        while (index > 0) {
            pointer = (index & 1) == 0 ? pointer.left() : pointer.right();
            index >>= 1;
        }
        return pointer;
    }

    private class Cell<T> {

        private Cell<T> left;
        private Cell<T> right;
        private T value;

        Cell<T> left() {
            return left = left != null ? left : new Cell<>();
        }

        Cell<T> right() {
            return right = right != null ? right : new Cell<>();
        }
    }
}