游戏排行榜的实现

在没有接触游戏行业的排行版时，就觉得排行版的实现非常不简单，也不知道是不是自己想的太过于复杂，然后自己特意去百度了游戏排行版的算法设计的比较(http://www.cocoachina.com/game/20150930/13638.html)，发现排行榜可大可小吧，具体看你如何做这个功能，我借鉴了别人写的方法，然后自己也实现了一波，发现算法真是一个好东西。
需求背景：

查看前top N的排名用户

查看自己的排名

用户积分变更后，排名及时更新

方案一
利用MySQL来实现，存放一张用户积分表user_score，结构如下

表 t_u_userscore

CREATE TABLE `t_u_userscore` (
  `UserId` int(11) NOT NULL COMMENT '用户ID',
  `Score` int(11) NOT NULL COMMENT '当前分数',
  PRIMARY KEY (`UserId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='玩家积分表';

表 t_u_user

CREATE TABLE `t_u_user` (
  `UserId` int(11) NOT NULL COMMENT '用户ID',
  `Username` varchar(255) NOT NULL COMMENT '用户名',
  `CurAllRank` int(11) NOT NULL DEFAULT '0' COMMENT '当前所有用户排名',
  `CurFriendRank` int(11) NOT NULL DEFAULT '0' COMMENT '当前所有用户排名',
  PRIMARY KEY (`UserId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='玩家信息表';

表t_u_friend

CREATE TABLE `t_u_friend` (
  `FriendId` int(11) NOT NULL COMMENT '朋友ID',
  `UserId` int(11) NOT NULL COMMENT '用户ID',
  `FriendRelation` varchar(255) DEFAULT '好友' COMMENT '关系描述',
  PRIMARY KEY (`FriendId`,`UserId`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='玩家交际描述';

表里面的数据就自己填写吧，这里我使用的是存储过程，自己写的存储过程并不多，如果大家有更好的方法，可以在下方评论告知我，不胜感激。
存储过程friendorder

CREATE DEFINER=`root`@`%` PROCEDURE `friendorder`(IN `userId` int)
BEGIN
    DECLARE curFriendRank INT DEFAULT 1; /*当前朋友圈排名*/
    DECLARE friendScore INT DEFAULT 0;   /*好友分数*/
    DECLARE friendCount INT DEFAULT 0;   /*好友总数量*/
    DECLARE v_curScore INT DEFAULT 0;    /*userId当前分数*/
    DECLARE v_friendId INT DEFAULT 0;    /*朋友id*/
    DECLARE v_index INT DEFAULT 0;   /*循环索引值*/
    SELECT count(1) INTO friendCount FROM `t_u_friend` f WHERE f.UserId = userId;
    SELECT `Score` INTO v_curScore FROM `t_u_userscore` f WHERE f.UserId = userId;
    WHILE v_index < friendCount DO
        SELECT f.FriendId INTO v_friendId FROM `t_u_user` u,`t_u_friend` f WHERE u.UserId = f.UserId AND u.UserId = userId LIMIT v_index,1;
        SELECT `score` INTO friendScore FROM `t_u_userscore` u WHERE u.UserId = v_friendId;
        IF friendScore > v_curScore THEN
             SET curFriendRank = curFriendRank + 1;
        END IF;
        SET v_index = v_index +1;
    END WHILE;
    UPDATE `t_u_user` u SET u.curFriendRank = CurFriendRank WHERE u.UserId = userId;
END

存储过程orderInfo

CREATE DEFINER=`root`@`%` PROCEDURE `orderInfo`()
BEGIN
    DECLARE count INT(11) DEFAULT 0; /*总共的数量*/
    DECLARE Startcur INT(11) DEFAULT 0; /*排名值*/
    DECLARE v_userId INT(11);
    SELECT COUNT(1) INTO count FROM `t_u_userscore`;
    WHILE Startcur < count DO
    SELECT `UserId` INTO v_userId FROM `t_u_userscore` ORDER BY `Score` DESC LIMIT Startcur, 1;
    SET Startcur = Startcur + 1;
    UPDATE `t_u_user` SET `CurAllRank` = Startcur WHERE `userId` = v_userId;
    CALL friendOrder(v_userId); /*同时更新好友圈排行*/
    END WHILE;
END

最后结果如下：

方案二
实现Comparable接口实现排序
对象类 Command

public class Command implements Comparable<Command> {

    private String commandName;

    private int commandTime;

    public Command(String commandName, int commandTime) {
        super();
        this.commandName = commandName;
        this.commandTime = commandTime;
    }
    @Override
    public int compareTo(Command o) {
        // TODO Auto-generated method stub
        if (this.getCommandTime() > o.getCommandTime()) {
            return -1;
        } else if (this.getCommandTime() < o.getCommandTime()) {
            return 1;
        }
        return 0;
    }

使用Collections.sort方法进行排序，之后是用list的indexof得到对象的索引值，这个索引值就是他的排名.
TestClass类

Command command1 = new Command("ssd", ran);
Command command2= new Command("ssd", ran);
Command command3 = new Command("ssd", ran);
Command command4 = new Command("ssd", ran);
Vector vector = new Vector();
vector.add(command1);
vector.add(command2);
vector.add(command3);
vector.add(command4);
Collections.sort(vector);

方案三
上述方法可以实现排行榜的功能，不过尽管是用线程安全的vector，但是在高并发的问题还是无法解决，而且在效率上也不是很快，所以可以使用skiplist。这里就简单的介绍下skipList。
SkipList这个数据结构名为跳跃表，再插入数据的同时就给它排序好，然后随机的生成层。Skip List是一种随机化的数据结构，基于并联的链表，其效率可比拟于二叉查找树（对于大多数操作需要O(log n)平均时间）。基本上，跳跃列表是对有序的链表增加上附加的前进链接，增加是以随机化的方式进行的，所以在列表中的查找可以快速的跳过部分列表(因此得名)。所有操作都以对数随机化的时间进行。Skip List可以很好解决有序链表查找特定值的困难。
在Java的API中已经有了实现：分别是
1： ConcurrentSkipListMap. 在功能上对应HashTable、HashMap、TreeMap。 在并发环境下，Java也提供ConcurrentHashMap这样的类来完成hashmap功能。
2： ConcurrentSkipListSet . 在功能上对应HashSet.
SkipList中的每一个对象的数据结构是这样的：

SkipList使用的时候是这样的

代码实现：
SkipListEntry.java

public Integer key; 

    public Integer value;

    public int rank;  // 排名

    public int pos;  //  标志位，主要方便打印内容

    public SkipListEntry left;
    public SkipListEntry right;
    public SkipListEntry up;
    public SkipListEntry down;

    public static int negInf = Integer.MIN_VALUE; //边界值
    public static int posInf = Integer.MAX_VALUE; //边界值

    public SkipListEntry(Integer key, Integer value) {
        this.key = key;
        this.value = value;
        rank = 0;
        this.left = this.right = this.up = this.down = null;
    }

SkipList.java

public class NSkipList {
    public SkipListEntry head; // 顶层的第一个元素
    public SkipListEntry tail; // 顶层的最后一个元素

    public int n; // 跳跃表中的元素个数

    public int h; // 跳跃表的高度
    public Random r; // 投掷硬币
    // 默认构造函数
    public NSkipList()
    {
        SkipListEntry p1, p2;

        p1 = new SkipListEntry(SkipListEntry.negInf, null);
        p2 = new SkipListEntry(SkipListEntry.posInf, null);

        head = p1;
        tail = p2;

        p1.right = p2;
        p2.left = p1;

        n = 0;
        h = 0;
        r = new Random();
    }

    /** 返回 包含的元素个数 */
    public int size() {
        return n;
    }

    /** 跳跃表是否为空 */
    public boolean isEmpty() {
        return (n == 0);
    }

    // 在最下面一层，找到要插入的位置前面的那个key
    public SkipListEntry findEntry(Integer k) {
        SkipListEntry p;
        p = head;

        while (true) {
            while (p.right.key != Integer.MAX_VALUE && p.right.key >= k) {
                p = p.right;
            }
            // 如果还有下一层，就到下一层继续查找
            if (p.down != null) {
                p = p.down;
            } else
                break; // 到了最下面一层 就停止查找
        }

        return (p); // p.key <= k
    }

    // 在最下面一层，这个方法主要是用于查询相同k值不同value的情况
    public SkipListEntry findEntry(Integer k, Integer value) {
        SkipListEntry p;
        p = head;
        // flag用来标识是否已经向左查询了
        boolean flag = false;
        while (true) {
            // 找到跳表位置,然后一直向右找,如果找到了直接返回
            while (p.right.key != Integer.MAX_VALUE && p.right.key >= k) {
                if(p.value != null && p.value.equals(value)){
                    return p;
                }
                p = p.right;
            }
            // 如果还有下一层，就到下一层继续查找
            if (p.down != null) {
                p = p.down;
            }
            // 如果没有下一层
            else {
                // 如果找到这个key值继续操作,否则返回null
                if (p.key == k) {
                    //如果已经向左查询过了,还没有找到，直接返回null
                    if(flag){
                        return null;
                    }
                    // 需要考虑跳表的时候,在上一层跳过了当前要查找的key值,所以需要往前找
                    if (p.left.key == k && !flag) {
                        flag = !flag;
                        while (p.left.key != Integer.MIN_VALUE && p.left.key <= k) {
                            if (p.value.equals(value)) {
                                return p;
                            }
                            p = p.left;
                        }
                    }
                }
                else{
                    return null;
                }
            }
        }

    }

    /** 返回和key绑定的值 */
    public Integer get(Integer k) {
        SkipListEntry p;

        p = findEntry(k);

        if (k.equals(p.getKey()))
            return (p.value);
        else
            return (null);
    }

    /** 放一个key-value到跳跃表中, 同时排序 */
    public Integer put(Integer k, Integer v) {
        SkipListEntry p, q;
        int i;

        p = findEntry(k);

        q = new SkipListEntry(k, v);
        q.left = p;
        q.right = p.right;
        p.right.left = q;
        p.right = q;

        i = 0; // 当前层 level = 0
        // 随机生成跳表层
        while (r.nextDouble() < 0.5) {

            // 如果超出了高度，需要重新建一个顶层
            if (i >= h) {
                SkipListEntry p1, p2;

                h = h + 1;
                p1 = new SkipListEntry(SkipListEntry.negInf, null);
                p2 = new SkipListEntry(SkipListEntry.posInf, null);

                p1.right = p2;
                p1.down = head;

                p2.left = p1;
                p2.down = tail;

                head.up = p1;
                tail.up = p2;

                head = p1;
                tail = p2;

            }

            while (p.up == null) {
                p = p.left;
            }
            p = p.up;

            SkipListEntry e;

            e = new SkipListEntry(k, null);
            e.left = p;
            e.right = p.right;
            e.down = q;

            p.right.left = e;
            p.right = e;
            q.up = e;

            q = e; // q 进行下一层迭代
            i = i + 1; // 当前层 +1

        }
        n = n + 1;
        getRank(k); //put一个value值时就排名一次
        return (null); // No old value
    }

    /** 排序方法 */
    public void getRank(Integer k) {
        SkipListEntry p;
        p = findEntry(k);
        while (p != null) {
            if (p.key != p.left.key) {
                p.rank = p.left.rank + 1;
            } else {
                p.rank = p.left.rank;
            }
            p = p.right;
        }
    }

    /** 移除一个key */
    public Integer remove(Integer key,Integer value) {
        SkipListEntry p = findEntry(key,value);
        if (p.key != key)
            return (null);
        while (p != null) {
            p.left.right = p.right;
            p.right.left = p.left;
            p = p.up;
        }
        getRank(key);
        return value;
    }

    public void printHorizontal() {
        String s = "";
        int i;
        SkipListEntry p;

        p = head;

        while (p.down != null) {
            p = p.down;
        }

        i = 0;
        while (p != null) {
            p.pos = i++;
            p = p.right;
        }

        p = head;
        while (p != null) {
            s = getOneRow(p);
            System.out.println(s);

            p = p.down;
        }
    }

    // 用了打印测试
    public String getOneRow(SkipListEntry p) {
        String s;
        int a, b, i;

        a = 0;

        s = "" + getStrKey(p.key) + "(" + p.value + ")";
        p = p.right;

        while (p != null) {
            SkipListEntry q;

            q = p;
            while (q.down != null)
                q = q.down;
            b = q.pos;

            s = s + " <-";

            for (i = a + 1; i < b; i++)
                s = s + "--------";

            s = s + "> " + getStrKey(p.key) + "(" + p.value + ")";

            a = b;

            p = p.right;
        }

        return (s);
    }

    // 用了打印测试
    public void printVertical() {
        String s = "";
        SkipListEntry p;
        p = head;
        while (p.down != null)
            p = p.down;

        while (p != null) {
            s = getOneColumn(p);
            System.out.println(s);

            p = p.right;
        }
    }

    // 用了打印测试
    public String getOneColumn(SkipListEntry p) {
        String s = "";
        while (p != null) {
            s = s + " " + p.key;
            p = p.up;
        }
        return (s);
    }
    // 为了替换边界值
    public String getStrKey(Integer key) {
        if (key == SkipListEntry.negInf) {
            return "-oo";
        } else if (key == SkipListEntry.posInf) {
            return "+oo";
        } else {
            return "" + key;
        }
    }

测试代码 TestClass.java

        NSkipList S = new NSkipList();
        S.printHorizontal();
        System.out.println("------");
//      S.printVertical(); 
        // System.out.println("======");

        S.put(123, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======");

        S.put(456, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======");

        S.put(1245, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======");

        S.put(12378, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======");

        S.put(664, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======");

        S.put(510, 123);
        S.printHorizontal();
        System.out.println("------");
        // S.printVertical(); // System.out.println("======"); S.put(5, 123);
        S.put(1, 1234);
        S.put(1, 1574);
        S.put(1, 978);
        S.put(3, 123);
        S.put(5678, 123);
        S.put(1167, 123);
        S.printHorizontal();
        System.out.println("------");
        SkipListEntry s = S.findEntry(1,1234);
        System.out.println("1234的排名是" + s.rank + ",value值是" + s.value);
        S.remove(1,1574);
        S.printHorizontal();
        System.out.println("------");
        s = S.findEntry(1,978);
        System.out.println("978的排名是" + s.rank + ",value值是" + s.value);
        s = S.findEntry(4568,222);
        if (s == null){
            System.out.println("没有找到!");
        }

运行结果：

上述代码参考地址：http://www.acmerblog.com/skip-list-impl-java-5773.html
skipList可以在不使用同步和锁的情况下，解决高并发问题。
方案四
使用redis的Sorted sets (有序集合)
将你要排序的值设置成sorted set的score，将具体的数据设置成相应的value，每次只需要执行一条ZADD命令即可
redis我自己也不是很了解，所以我附上这个链接
http://lib.csdn.net/article/34/40010?knId=1006
想学习的小伙伴就去看看吧 0.0.