if (server.zset_max_ziplist_entries ==  ||

server.zset_max_ziplist_value < sdslen(c->argv[scoreidx+]->ptr))

        {

            zobj = createZsetObject(); //创建zset

        } else {

            zobj = createZsetZiplistObject();//创建ziplist

        }

/* Insert item at "p". */

unsigned char *__ziplistInsert(unsigned char *zl, unsigned char *p, unsigned char *s, unsigned int slen) {

    size_t curlen = intrev32ifbe(ZIPLIST_BYTES(zl)), reqlen;

    unsigned int prevlensize, prevlen = ;

    size_t offset;

    int nextdiff = ;

    unsigned char encoding = ;

    long long value = ; /* initialized to avoid warning. Using a value

                                    that is easy to see if for some reason

                                    we use it uninitialized. */

    zlentry tail;

    /* Find out prevlen for the entry that is inserted. */

    //插入位置前面一个entry节点占用的字节数prevlen

    if (p[] != ZIP_END) {//插入节点不在末尾节点,直接从p的前面字节读

        ZIP_DECODE_PREVLEN(p, prevlensize, prevlen);

    } else {//插入节点在末尾位置,找到末尾节点

        unsigned char *ptail = ZIPLIST_ENTRY_TAIL(zl);

        if (ptail[] != ZIP_END) {

            prevlen = zipRawEntryLength(ptail);

        }

    }

    /* See if the entry can be encoded */

    if (zipTryEncoding(s,slen,&value,&encoding)) {//判断s是否可以转化为整数,并将整数值和enconding分别存在value和encoding指针

        /* 'encoding' is set to the appropriate integer encoding */

        reqlen = zipIntSize(encoding);//整数值长度

    } else {

        /* 'encoding' is untouched, however zipStoreEntryEncoding will use the

         * string length to figure out how to encode it. */

        reqlen = slen;//字符串长度

    }

    /* We need space for both the length of the previous entry and

     * the length of the payload. */

    //得出新插入节点占用的总字节数reqlen

    reqlen += zipStorePrevEntryLength(NULL,prevlen);

    reqlen += zipStoreEntryEncoding(NULL,encoding,slen);

    /* When the insert position is not equal to the tail, we need to

     * make sure that the next entry can hold this entry's length in

     * its prevlen field. */

    //插入新节点不在末尾位置,则插入位置p所指向的entry节点的prevlen,

    //值会变成新插入节点的总长度,且prevlen所占用的字节数可能会变化,

    //nextdiff表示新插入节点下一节点的prevlen需要空间的变化,负值表示变小,

    //正值表示扩大

    int forcelarge = ;

    nextdiff = (p[] != ZIP_END) ? zipPrevLenByteDiff(p,reqlen) : ;

    if (nextdiff == - && reqlen < ) {

        nextdiff = ;

        forcelarge = ;

    }

    /* Store offset because a realloc may change the address of zl. */

    offset = p-zl;

    zl = ziplistResize(zl,curlen+reqlen+nextdiff);//重新分配空间,并将zl的每字节都填充到新分配的内存中

    p = zl+offset;

    //将p后面的数据项进行移动

    /* Apply memory move when necessary and update tail offset. */

    if (p[] != ZIP_END) {

        /* Subtract one because of the ZIP_END bytes */

        memmove(p+reqlen,p-nextdiff,curlen-offset-+nextdiff);

        /* Encode this entry's raw length in the next entry. */

        if (forcelarge)//设置下一个节点的prevlen

            zipStorePrevEntryLengthLarge(p+reqlen,reqlen);

        else

            zipStorePrevEntryLength(p+reqlen,reqlen);

        /* Update offset for tail */

        ZIPLIST_TAIL_OFFSET(zl) =

            intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+reqlen);

        /* When the tail contains more than one entry, we need to take

         * "nextdiff" in account as well. Otherwise, a change in the

         * size of prevlen doesn't have an effect on the *tail* offset. */

        zipEntry(p+reqlen, &tail);

        if (p[reqlen+tail.headersize+tail.len] != ZIP_END) {

            ZIPLIST_TAIL_OFFSET(zl) =

                intrev32ifbe(intrev32ifbe(ZIPLIST_TAIL_OFFSET(zl))+nextdiff);

        }

    } else {

        /* This element will be the new tail. */

        ZIPLIST_TAIL_OFFSET(zl) = intrev32ifbe(p-zl);

    }

    /* When nextdiff != 0, the raw length of the next entry has changed, so

     * we need to cascade the update throughout the ziplist */

    if (nextdiff != ) {

        offset = p-zl;

        zl = __ziplistCascadeUpdate(zl,p+reqlen);

        p = zl+offset;

    }

    /* Write the entry */

    //将新数据项放入插入位置

    p += zipStorePrevEntryLength(p,prevlen);

    p += zipStoreEntryEncoding(p,encoding,slen);

    if (ZIP_IS_STR(encoding)) {

        memcpy(p,s,slen);

    } else {

        zipSaveInteger(p,value,encoding);

    }

    ZIPLIST_INCR_LENGTH(zl,);

    return zl;

}

typedef struct zset {

    dict *dict;//字典

    zskiplist *zsl;//跳表

} zset;

int zslRandomLevel(void) {

    //随机生成节点层数,当第i层节点存在时，第i+1节点存在的概率为ZSKIPLIST_P = 1/4

    //ZSKIPLIST_MAXLEVEL 64,表示节点的最大层数

    int level = ;

    while ((random()&0xFFFF) < (ZSKIPLIST_P * 0xFFFF))

        level += ;

    return (level<ZSKIPLIST_MAXLEVEL) ? level : ZSKIPLIST_MAXLEVEL;

}

/* ZSETs use a specialized version of Skiplists */

typedef struct zskiplistNode {

    sds ele;//实际存储的数据

    double score;//分值

    struct zskiplistNode *backward;//后退指针,指向前一个节点

    struct zskiplistLevel {

        struct zskiplistNode *forward;//前进指针,指向下一个节点

        unsigned long span;//跨度,表示该层链表的这一节点到下一节点跨越的节点数,用于计算rank

    } level[];//层级数组,每个层级都有到下一个节点的指针和跨度

} zskiplistNode;//跳表节点

typedef struct zskiplist {

    struct zskiplistNode *header, *tail;//跳表头节点和尾节点

    unsigned long length;//跳表元素个数

    int level;//跳表的最高层数(不包括头节点,头节点实际上并不存储数据)

} zskiplist;

zskiplistNode *zslInsert(zskiplist *zsl, double score, sds ele) {

    zskiplistNode *update[ZSKIPLIST_MAXLEVEL], *x;

    unsigned int rank[ZSKIPLIST_MAXLEVEL];

    int i, level;

    serverAssert(!isnan(score));

    x = zsl->header;

    for (i = zsl->level-; i >= ; i--) {

        /* store rank that is crossed to reach the insert position */

        //rank[i]初始化为rank[i+1],所以rank[i]-rank[i+1]表示在i层走过的节点数

        rank[i] = i == (zsl->level-) ?  : rank[i+];

        while (x->level[i].forward &&

                (x->level[i].forward->score < score ||

                    (x->level[i].forward->score == score &&

                    sdscmp(x->level[i].forward->ele,ele) < )))

        {

            rank[i] += x->level[i].span;

            x = x->level[i].forward;

        }

        // 记录将要和新节点相连接的节点,x表示新节点在i层连接的上一节点

        update[i] = x;

    }

    /* we assume the element is not already inside, since we allow duplicated

     * scores, reinserting the same element should never happen since the

     * caller of zslInsert() should test in the hash table if the element is

     * already inside or not. */

    level = zslRandomLevel();//随机生成此节点的层数

    if (level > zsl->level) {

        for (i = zsl->level; i < level; i++) {

            rank[i] = ;

            update[i] = zsl->header;

            update[i]->level[i].span = zsl->length;

        }

        zsl->level = level;

    }

    x = zslCreateNode(level,score,ele);

    for (i = ; i < level; i++) {

        x->level[i].forward = update[i]->level[i].forward;

        update[i]->level[i].forward = x;

        /* update span covered by update[i] as x is inserted here */

        //rank[0]表示0层链表，插入节点x左边的节点数

        //rank[i]表示i层链表,插入节点x左边的节点数

        //rank[0] - rank[i]+1表示i层链表,x前一节点到x的跨度

        x->level[i].span = update[i]->level[i].span - (rank[] - rank[i]);

        update[i]->level[i].span = (rank[] - rank[i]) + ;

    }

    /* increment span for untouched levels */

    //在level及之上的每层,update[i]到下一节点的距离由于插入了x节点而加1

    for (i = level; i < zsl->level; i++) {

        update[i]->level[i].span++;

    }

    //更新后退指针

    x->backward = (update[] == zsl->header) ? NULL : update[];

    if (x->level[].forward)

        x->level[].forward->backward = x;

    else

        zsl->tail = x;

    zsl->length++;

    return x;

}