如何支持O(logn)时间复杂度的函数操作的数据结构？

一种支持这种时间复杂度的数据结构是平衡二叉搜索树，如红黑树、AVL树等。这些树的查找、插入、删除等操作的时间复杂度都为O(log n)。以下是一个用Java实现的红黑树示例：

class Node {
    int key;
    Node left, right;
    boolean isRed;

    public Node(int key) {
        this.key = key;
        isRed = true;
    }
}

class RedBlackTree {
    Node root;

    public void insert(int key) {
        root = insert(root, key);
        root.isRed = false;
    }

    private Node insert(Node x, int key) {
        if (x == null) return new Node(key);

        if (key < x.key) x.left = insert(x.left, key);
        else if (key > x.key) x.right = insert(x.right, key);

        if (isRed(x.right) && !isRed(x.left)) x = rotateLeft(x);
        if (isRed(x.left) && isRed(x.left.left)) x = rotateRight(x);
        if (isRed(x.left) && isRed(x.right)) flipColors(x);

        return x;
    }

    private boolean isRed(Node x) {
        if (x == null) return false;
        return x.isRed;
    }

    private Node rotateLeft(Node h) {
        Node x = h.right;
        h.right = x.left;
        x.left = h;
        x.isRed = h.isRed;
        h.isRed = true;
        return x;
    }

    private Node rotateRight(Node h) {
        Node x = h.left;
        h.left = x.right;
        x.right = h;
        x.isRed = h.isRed;
        h.isRed = true;
        return x;
    }

    private void flipColors(Node h) {
        h.isRed = true;
        h.left.isRed = false;
        h.right.isRed = false;
    }
}