实现游戏记分牌 API 的最佳数据结构

Question

I want to design a Scoreboard for a game. The score board is sorted in descending order, based on score. The Scoreboard looks like below:
-----------------------------
|User Name | score |
-----------------------------
|DragonSlayer | 98765 |
|Pikachu | 98762 |
......
|User123 | 12568 |
-----------------------------

The basic APIs that needs to be supported are:
String getLeader() -> returns the user name which is currently at the top of the leaderboard.
int getScore(username) -> returns the corresponding score for a given username.
List<UserAndScore> getTop(int n) -> returns top n number of usernames and their corresponding score.
void insert(String userName, int score) -> insert the score for a given user.

What could be the best data structure (in terms of speed) for working with the leaderboard. I have thought of using 2 data structures and their corresponding time complexity for each API:

1. HashMap -> getLeader() API takes O(n). getScore() API takes O(1), getTop() API takes O(nlogn) (where O(nlogn) is the time taken for sorting the values in map and insert API takes O(1).
2. LinkedList -> While inserting the data, I would ensure that the data are in descending order. getLeader() API takes O(1), as we are returning the first element, getScore() API takes O(n), getTop() API takes O(1) and insert API takes O(n).

I'm more leaning towards using LinkedList as it is a leaderboard and getLeader() and getTop(n) are the frequently called APIs.

I thought of using a TreeMap . If I use the 'username' as key, the data would be ordered by username, but, I would like to have it by score though. It is not right to use the 'score' as the key in the TreeMap .

is there a data structure which could be having time complexity less than the LinkedList implementation?

is there a better data structure for implementing this scenario?

Thanks, Pal

Answer 1

You can have both in maps, just create an enclosing class to make the invariants satisfied. For example

static class Bimap {
    Map<String, Integer> map = new HashMap<>();
    SortedMap<Integer, Set<String>> rmap = new TreeMap<>(Collections.reverseOrder());

    // top score can have more than one entry
    // or user getTop(1).
    List<String> getLeader() {
        return new ArrayList<>(rmap.get(rmap.firstKey()));
    }

    int getScore(String username) {
        return map.get(username);
    }

    List<String> getTop(int n) {
        List<String> top = new ArrayList<>();
        int counter=0;
        for(Integer score : rmap.keySet()) {
            top.addAll(rmap.get(score));
            counter++;
            if(counter >= n) break;
        }
        return top;
    }

    // not to leave obsolete scores to keep the invariants satisfied
    void insert(String userName, int score) {
        Integer pscore = map.put(userName, score);
        if (null != pscore) {
            Set<String> names = rmap.get(pscore);
            names.remove(userName);
            if (names.size() == 0) {
                rmap.remove(pscore);
            }
        }
        rmap.computeIfAbsent(score, k -> new HashSet<>()).add(userName);
    }

}

Not tested except few trivial cases. Caveat Emptor!