我试图做一个游戏排行榜使用排序链表。我可以通过按降序排列点来做到这一点，即从高点到低点。此外，我还需要把球员的名字和积分放在一起。问题来了。我实现的sll（排序链表）是一种整数数据类型，它在对数字进行排序时与整数数据类型完美地结合在一起。

SortedListInterface<Integer> Player = new LeaderboardSortedLinkedList<Integer>();

但是当我尝试放置使用字符串的播放器名称时，它将无法这样做，因为点数据类型将需要跟随播放器名称的数据类型。以下是驾驶员等级代码：

public class testLeaderboard {

    public static void main(String[] args) {
        SortedListInterface<Integer> Player = new LeaderboardSortedLinkedList<Integer>();

            Player.add(1000000);
            Player.add(500000);
            Player.add(250000);
            Player.add(125000);
            Player.add(64000);
            Player.add(32000);
            Player.add(16000);
            Player.add(8000);
            Player.add(4000);
            Player.add(2000);
            Player.add(1000);
            Player.add(500);
            Player.add(300);
            Player.add(200);
            Player.add(100);

        System.out.printf("=================================\n" 
                         + "          Leaderboard\n"
                         +"=================================\n");

        for(int i=0; i< Player.size();i++){

            System.out.printf("%3d. %s\n",(i+1), Player.get(i+1));
        }

    }

}

下面是实体类

public class Player {
    private String name;
    private int prize;

    public Player(String name, int prize) {
        this.name = name;
        this.prize = prize;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getPrize() {
        return prize;
    }

    public void setPrize(int prize) {
        this.prize = prize;
    }

    @Override
    public String toString() {
        return "Player{" + "name=" + name + ", prize=" + prize + '}';
    }
}

这是自定义排序的行列表

public class LeaderboardSortedLinkedList<T extends Comparable<T>> implements SortedListInterface<T> {

    private Node firstNode;
    private int length;

    public LeaderboardSortedLinkedList() {
        firstNode = null;
        length = 0;
    }

    public boolean add(T newEntry) {
        Node newNode = new Node(newEntry);

        Node nodeBefore = null; 
        Node currentNode = firstNode;   
        while (currentNode != null && newEntry.compareTo(currentNode.data) < 0) {
            nodeBefore = currentNode;
            currentNode = currentNode.next;
        }

        if (isEmpty() || (nodeBefore == null)) { // CASE 1: add at beginning
            newNode.next = firstNode;
            firstNode = newNode;
        } else {    // CASE 2: add in the middle or at the end, i.e. after nodeBefore
            newNode.next = currentNode;
            nodeBefore.next = newNode;
        }
        length++;
        return true;
    }

    public boolean contains(T anEntry) {
        boolean found = false;
        Node tempNode = firstNode;
        int pos = 1;

        while (!found && (tempNode != null)) {
            if (anEntry.compareTo(tempNode.data) <= 0) {
                found = true;
            } else {
                tempNode = tempNode.next;
                pos++;
            }
        }
        if (tempNode != null && tempNode.data.equals(anEntry)) {
            return true;
        } else {
            return false;
        }
    }

    public int size(){
         int count = 0;    
        //Node current will point to head    
        Node current = firstNode;    

        while(current != null) {    
            //Increment the count by 1 for each node    
            count++;    
            current = current.next;    
        }    
        return count;   
    }

     public T get(int position){
        T result = null;

    if ((position >= 1) && (position <= length)) {
      Node currentNode = firstNode;
      for (int i = 0; i < position - 1; ++i) {
        currentNode = currentNode.next;     // advance currentNode to next node
      }
      result = currentNode.data;    // currentNode is pointing to the node at givenPosition
    }

    return result;
    }

    public final void clear() {
        firstNode = null;
        length = 0;
    }

    public int getLength() {
        return length;
    }

    public boolean isEmpty() {
        return (length == 0);
    }

    public String toString() {
        String outputStr = "";
        Node currentNode = firstNode;
        while (currentNode != null) {
            outputStr += currentNode.data + "\n";;
            currentNode = currentNode.next;
        }
        return outputStr;
    }

    private class Node {

        private T data;
        private Node next;

        private Node(T data) {
            this.data = data;
            next = null;
        }

        private Node(T data, Node next) {
            this.data = data;
            this.next = next;
        }
    }
}

结果就在这里

=================================
          Leaderboard
=================================
  1. 1000000
  2. 500000
  3. 250000
  4. 125000
  5. 64000
  6. 32000
  7. 16000
  8. 8000
  9. 4000
 10. 2000
 11. 1000
 12. 500
 13. 300
 14. 200
 15. 100

下面是我对point with string数据类型的测试，因为我想不出在我的自定义adt中同时使用player name和point两种不同数据类型的方法。

public class testLeaderboard {

    public static void main(String[] args) {
        SortedListInterface<String> Player = new LeaderboardSortedLinkedList<String>()

            Player.add("1000000");
            Player.add("500000");
            Player.add("250000");
            Player.add("125000");
            Player.add("64000");
            Player.add("32000");
            Player.add("16000");
            Player.add("8000");
            Player.add("4000");
            Player.add("2000");
            Player.add("1000");
            Player.add("500");
            Player.add("300");
            Player.add("200");
            Player.add("100");

    System.out.println(Player);
    }

这是比较字符串第一个字母的结果。

8000
64000
500000
500
4000
32000
300
250000
2000
200
16000
125000
1000000
1000
100

在一个adt中是否可以同时使用字符串和整数，因为如果我不能这样做，我将无法对点进行排序。很抱歉问了这么长的问题。我是非常新的数据结构和算法，所以我真的需要一些帮助在这方面。非常感谢。