// score可以相同，member不能重復(fù)
type SortedSet struct {
	dict map[string]*Pair // 利用map基于member去重
	skl  *skiplist        // 利用skl進(jìn)行排序
}
// 要存儲(chǔ)的值
type Pair struct {
	Member string
	Score  float64
}

type  node struct{
	val int64
}
var curNode *node = &node{val:9}
if pre.next != nil && pre.next.val < curNode.val
{
	pre = pre.next
}
// 插入
pre.next = curNode

type Level struct {
    forward *node// 每層的指向
    span int64// 每層的跨度
}
type node struct {
    val int64
    level []*Level //每個(gè)節(jié)點(diǎn)的層
}
var maxlevel = 5
// 被插入的節(jié)點(diǎn)9 
var curNode *node = &node{val:9}
// dummy 節(jié)點(diǎn)
var dummy *node = &node{val:0}
// pre一開(kāi)始指向dummy節(jié)點(diǎn)
var pre *node = dummy
// 從最高層開(kāi)始，這里的i表示層高索引
for i := maxlevel-1;i >= 0;i-- {
    for pre.level[i].forward != nil && pre.level[i].forward.val < curNode.val {
        pre = pre.level[i].forward
    }
}

// zadd key score member [score member...]
func cmdZAdd(db *DB, args [][]byte) protocol.Reply {
	//... 省略...
    // 獲取有序集合對(duì)象
	sortedSet, _, reply := db.getOrInitSortedSetObject(key)
	if reply != nil {
		return reply
	}
	// 將pairs保存到有序集合中
	i := int64(0)
	for _, pair := range pairs {
		if sortedSet.Add(pair.Member, pair.Score) {
			i++ // 新增的個(gè)數(shù)
		}
	}
	//... 省略...
}

// bool 為true表示新增， false表示修改
func (s *SortedSet) Add(member string, score float64) bool {
	pair, ok := s.dict[member]
	s.dict[member] = &Pair{
		Member: member,
		Score:  score,
	}
	// 說(shuō)明是重復(fù)添加
	if ok {
		// 分值不同
		if score != pair.Score {
			// 將原來(lái)的從跳表中刪除
			s.skl.remove(pair.Member, pair.Score)
			// 插入新值
			s.skl.insert(member, score)
		}
		// 分值相同，do nothing...
		returnfalse
	}
	// 新增
	s.skl.insert(member, score)
	returntrue
}

// 增
func (s *skiplist) insert(member string, score float64) *node {
	beforeNode := make([]*node, defaultMaxLevel)      // 每一層的前驅(qū)節(jié)點(diǎn)
	beforeNodeOrder := make([]int64, defaultMaxLevel) // 每一層的前驅(qū)節(jié)點(diǎn)排序編號(hào)
	node := s.header
	// i從最高層遍歷，通過(guò)遍歷，將member和score在每一層的前驅(qū)節(jié)點(diǎn)全部保存在 beforeNode中，以及節(jié)點(diǎn)的排序保存在beforeNodeOrder
	for i := s.maxLevel - 1; i >= 0; i-- {
		// 節(jié)點(diǎn)node的排序
		if i == s.maxLevel-1 {
			beforeNodeOrder[i] = 0
		} else {
			beforeNodeOrder[i] = beforeNodeOrder[i+1]
		}
		// 節(jié)點(diǎn)node在當(dāng)前i層的forward不為空
		for node.levels[i].forward != nil &&
			// node在層levels[i]的forward節(jié)點(diǎn)，分值 < score 或者 分值相同但是成員 < member，說(shuō)明forward指向的節(jié)點(diǎn)，作為下一個(gè)前驅(qū)節(jié)點(diǎn)
			(node.levels[i].forward.Score < score || (node.levels[i].forward.Score == score && node.levels[i].forward.Member < member)) {
			beforeNodeOrder[i] += int64(node.levels[i].span) // 更新節(jié)點(diǎn)node的編號(hào)
			node = node.levels[i].forward                    // 更新當(dāng)前節(jié)點(diǎn)node
		}
		beforeNode[i] = node
	}
	// 新節(jié)點(diǎn)層高
	newLevel := randomLevel()
	// 如果新層高比當(dāng)前已經(jīng)存在的層高s.maxLevel都要高，說(shuō)明還缺少了 newLevel - s.maxLevel范圍的前驅(qū)節(jié)點(diǎn)
	if newLevel > s.maxLevel {
		for i := s.maxLevel; i < newLevel; i++ {
			// beforeNode[i] 表示在i層的前驅(qū)節(jié)點(diǎn)
			beforeNode[i] = s.header
			beforeNodeOrder[i] = 0
			beforeNode[i].levels[i].forward = nil
			beforeNode[i].levels[i].span = s.length
		}
	}
	node = newNode(newLevel, member, score)
	// 將節(jié)點(diǎn)插入到多層鏈表中，僅僅對(duì)[0,newLevel）范圍進(jìn)行節(jié)點(diǎn)拼接
	for i := int16(0); i < newLevel; i++ {
		//也就是在每一層插入節(jié)點(diǎn)
		node.levels[i].forward = beforeNode[i].levels[i].forward
		beforeNode[i].levels[i].forward = node
		// 更新本層節(jié)點(diǎn)跨度
		node.levels[i].span = beforeNode[i].levels[i].span - (beforeNodeOrder[0] - beforeNodeOrder[i])
		beforeNode[i].levels[i].span = beforeNodeOrder[0] - beforeNodeOrder[i] + 1
	}
	// 如果新節(jié)點(diǎn)的高度很低，比最高低很多
	for i := newLevel; i < s.maxLevel; i++ {
		beforeNode[i].levels[i].span++ // 超過(guò)的節(jié)點(diǎn)的跨度默認(rèn)+1
	}
	// 修改第0層的 backward指向
	if beforeNode[0] == s.header {
		node.backward = nil
	} else {
		node.backward = beforeNode[0]
	}
	if node.levels[0].forward != nil {
		node.levels[0].forward.backward = node
	} else { // 說(shuō)明node是最后一個(gè)節(jié)點(diǎn)
		s.tailer = node
	}
	// 因?yàn)樾略?，?shù)量+1
	s.length++
	return node
}

// 如果新層高比當(dāng)前已經(jīng)存在的層高s.maxLevel都要高，說(shuō)明還缺少了 newLevel - s.maxLevel范圍的前驅(qū)節(jié)點(diǎn)
	if newLevel > s.maxLevel {
		for i := s.maxLevel; i < newLevel; i++ {
			// beforeNode[i] 表示在i層的前驅(qū)節(jié)點(diǎn)
			beforeNode[i] = s.header
			beforeNodeOrder[i] = 0
			beforeNode[i].levels[i].forward = nil
			beforeNode[i].levels[i].span = s.length
		}
	}

// 如果新節(jié)點(diǎn)的高度很低，比最高低很多
	for i := newLevel; i < s.maxLevel; i++ {
		beforeNode[i].levels[i].span++ // 超過(guò)的節(jié)點(diǎn)的跨度默認(rèn)+1
	}