实现 Redis 有序集合结构

const maxLevel = 16 // Maximum number of levels in the skip list
 
// Node represents a node in the skip list
type Node struct {
	Member  string
	Score   float64
	Forward []*Node // Forward points at different levels
}
 
// SkipList represents a skip list
type SkipList struct {
	header *Node // Header node
	tail   *Node // Tail node
	level  int   // Current max level of the skip list
	length int   // Length of the skip list
	rand   *rand.Rand
}

// New SkipList creates a new skip list
func NewSkipList() *SkipList {
	header := &Node{
		Forward: make([]*Node, maxLevel), // 初始化头节点的 Forward 切片
	}
	return &SkipList{
		header: header,
		level:  1, // 初始层级为 1
		rand:   rand.New(rand.NewSource(time.Now().UnixNano())), // 初始化随机数生成器
	}
}

// randomLevel generates a random level for the new node
func (sl *SkipList) randomLevel() int {
	level := 1
	// Increase level with 25% probability
	for level < maxLevel && sl.rand.Float32() < 0.25 {
		level++
	}
	return level
}

// Insert inserts a new member with the given score into the skip list
func (sl *SkipList) Insert(member string, score float64) {
	update := make([]*Node, maxLevel) // 存储每一层需要更新的前驱节点
	x := sl.header
 
	// 1. 查找插入位置：从最高层向下查找
	for i := sl.level - 1; i >= 0; i-- {
		// 在当前层向右查找，直到找到第一个 Score 更大或 Member 更大的节点
		for x.Forward[i] != nil &&
			(x.Forward[i].Score < score ||
				(x.Forward[i].Score == score && x.Forward[i].Member < member)) {
			x = x.Forward[i]
		}
		// 记录下这一层需要修改 Forward 指针的节点 (即新节点的前驱)
		update[i] = x
	}
	// 此时 x 是最底层中小于新节点的最后一个节点
 
	// 2. 生成新节点的随机层级
	level := sl.randomLevel()
 
	// 3. 更新 SkipList 的最大层级 (如果需要)
	if level > sl.level {
		// 如果新节点的层级超过当前最大层级，需要扩展 update 数组
		for i := sl.level; i < level; i++ {
			update[i] = sl.header // 新增层级的前驱节点是 header（因为这个新的层级为空）
		}
		sl.level = level // 更新 SkipList 的当前最大层级
	}
 
	// 4. 创建新节点
	newNode := &Node{
		Member:  member,
		Score:   score,
		Forward: make([]*Node, level), // Forward 切片大小为新节点的层级
	}
 
	// 5. 更新指针，将新节点链入 SkipList
	for i := 0; i < level; i++ {
		newNode.Forward[i] = update[i].Forward[i] // 新节点的 Forward 指向原前驱节点的下一个节点
		update[i].Forward[i] = newNode          // 前驱节点的 Forward 指向新节点
	}
 
	// 6. 更新尾节点指针 (如果新节点是最后一个节点)
	if newNode.Forward[0] == nil {
		sl.tail = newNode
	}
 
	sl.length++ // 更新 SkipList 的长度
}
 

// Delete removes an element from the skip list
func (sl *SkipList) Delete(member string, score float64) bool {
	update := make([]*Node, maxLevel)
	x := sl.header
 
	// 1. 查找目标节点的前驱节点
	for i := sl.level - 1; i >= 0; i-- {
		for x.Forward[i] != nil &&
			(x.Forward[i].Score < score ||
				(x.Forward[i].Score == score && x.Forward[i].Member < member)) {
			x = x.Forward[i]
		}
		update[i] = x // 记录每层的前驱
	}
 
	// 2. 定位目标节点
	// x 现在是最底层目标节点的前驱，x.Forward[0] 可能是目标节点
	targetNode := x.Forward[0]
 
	// 3. 检查节点是否存在且匹配
	if targetNode != nil && targetNode.Score == score && targetNode.Member == member {
		// 4. 更新指针，在所有层级中移除目标节点
		for i := 0; i < sl.level; i++ {
			// 如果 update[i] 的下一个节点不是目标节点，说明目标节点不在这一层或更高层
			if update[i].Forward[i] != targetNode {
				break // 可以提前结束
			}
			// 将前驱节点的 Forward 指向目标节点的下一个节点，完成移除
			update[i].Forward[i] = targetNode.Forward[i]
		}
 
		// 5. 更新尾节点指针 (如果删除的是尾节点)
		if targetNode == sl.tail {
			// 新的尾节点是 update[0] (最底层的前驱)
			// 如果 update[0] 是 header，说明列表空了，tail 应为 nil
			if update[0] == sl.header {
				sl.tail = nil
			} else {
				sl.tail = update[0]
			}
		}
 
		// 6. 更新 SkipList 的最大层级 (如果需要)
		// 如果删除节点后，最高层变为空，则降低 SkipList 的 level
		for sl.level > 1 && sl.header.Forward[sl.level-1] == nil {
			sl.level--
		}
 
		sl.length-- // 更新长度
		return true // 删除成功
	}
 
	return false // 未找到或不匹配，删除失败
}

// CountInRange counts elements with score between min and max
func (sl *SkipList) CountInRange(min, max float64) int {
	count := 0
	x := sl.header
 
	// Find first node with score >= min
	for i := sl.level - 1; i >= 0; i-- {
		for x.Forward[i] != nil && x.Forward[i].Score < min {
			x = x.Forward[i]
		}
	}
 
	// Traverse nodes with score <= max
	x = x.Forward[0]
	for x != nil && x.Score <= max {
		count++
		x = x.Forward[0]
	}
 
	return count
}

// RangeByScore returns members with scores between min and max
func (sl *SkipList) RangeByScore(min, max float64, offset, count int) []string {
	result := []string{}
	x := sl.header
 
	// Find first node with score >= min
	for i := sl.level - 1; i >= 0; i-- {
		for x.Forward[i] != nil && x.Forward[i].Score < min {
			x = x.Forward[i]
		}
	}
 
	// Traverse nodes with score <= max
	x = x.Forward[0]
	skipped := 0
 
	for x != nil && x.Score <= max {
		if offset < 0 || skipped >= offset {
			result = append(result, x.Member)
			// Stop if we've collected enough elements
			if count > 0 && len(result) >= count {
				break
			}
		} else {
			skipped++
		}
		x = x.Forward[0]
	}
 
	return result
}

// RangeByRank returns members by rank (position)
func (sl *SkipList) RangeByRank(start, stop int) []string {
	result := []string{}
 
	// Handle negative indices and out of range
	if start < 0 {
		start = sl.length + start
	}
	if stop < 0 {
		stop = sl.length + stop
	}
	if start < 0 {
		start = 0
	}
	if stop >= sl.length {
		stop = sl.length - 1
	}
	if start > stop || start >= sl.length {
		return result
	}
 
	// Traverse to start position
	x := sl.header.Forward[0]
	for i := 0; i < start && x != nil; i++ {
		x = x.Forward[0]
	}
 
	// Collect members between start and stop
	for i := start; i <= stop && x != nil; i++ {
		result = append(result, x.Member)
		x = x.Forward[0]
	}
 
	return result
}

// GetRank returns the rank of a member
func (sl *SkipList) GetRank(member string, score float64) int {
	rank := 0
	x := sl.header
 
	for i := sl.level - 1; i >= 0; i-- {
		for x.Forward[i] != nil &&
			(x.Forward[i].Score < score ||
				(x.Forward[i].Score == score && x.Forward[i].Member < member)) {
			rank += 1 // Count nodes we're skipping
			x = x.Forward[i]
		}
	}
 
	x = x.Forward[0]
	if x != nil && x.Member == member {
		return rank
	}
 
	return -1 // Member not found
}

// getAsZSet retrieves the ZSet stored at key, or creates a new one if it doesn't exist
func getAsZSet(db *DB, key string) (zset.ZSet, bool) {
	// Get entity from database
	entity, exists := db.GetEntity(key)
	if !exists {
		return zset.NewZSet(), false
	}
 
	// Check if entity is a ZSet
	zsetObj, ok := entity.Data.(zset.ZSet)
	if !ok {
		return nil, true // Key exists but is not a ZSet
	}
 
	return zsetObj, true
}

// ZSet is the interface that represents a Redis sorted set
type ZSet interface {
	
}
 
const (
	encodingListpack = iota
	encodingSkiplist
)
 
// 用于限制 Listpack 的最大长度，超过长度后，使用 Skiplist 来存储
const listpackMaxSize = 128
 
type zset struct {
	encoding int
	listpack [][2]string
	dict     map[string]float64
	skiplist *skiplist.SkipList
}
 
// New creates a new zset
func NewZSet() ZSet {
	return &zset{
		encoding: encodingListpack,
		listpack: make([][2]string, 0),
	}
}

ZADD key score member [score member ...]

ZADD myzset 1 member1 2 member2

// execZAdd implements the ZADD command
// ZADD key [NX|XX] [CH] [INCR] score member [score member ...]
func execZAdd(db *DB, args [][]byte) resp.Reply {
	if len(args) < 3 || len(args)%2 == 0 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zadd' command")
	}
 
	key := string(args[0])
 
	// Get or create ZSet
	zsetObj, exists := getAsZSet(db, key)
	if exists && zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	added := 0
	for i := 1; i < len(args); i += 2 {
		scoreStr := string(args[i])
		member := string(args[i+1])
 
		// Parse score
		score, err := parseFloat(scoreStr)
		if err != nil {
			return err
		}
 
		// Add member to ZSet
		if zsetObj.Add(member, score) {
			added++
		}
	}
 
	// Store ZSet in database
	db.PutEntity(key, &database.DataEntity{Data: zsetObj})
 
	// Add AOF record
	db.addAof(utils.ToCmdLineWithName("ZADD", args...))
 
	return reply.MakeIntReply(int64(added))
}

type ZSet interface {
	Add(member string, score float64) bool
}
 
// Add adds a member with the given score to the sorted set
// Returns true if the element was added as a new member, false if the score was updated
func (z *zset) Add(member string, score float64) bool {
	// Check if we're using listpack encoding
	if z.encoding == encodingListpack {
		// Check if member already exists in listpack
		for i, pair := range z.listpack {
			if pair[0] == member {
				// Update score if member already exists
				z.listpack[i][1] = formatScore(score)
				return false
			}
		}
 
		// Add new member to listpack
		z.listpack = append(z.listpack, [2]string{member, formatScore(score)})
 
		// Convert to skiplist encoding if listpack grows too large
		if len(z.listpack) > listpackMaxSize {
			z.convertToSkiplist()
		}
		return true
	}
 
	// Using skiplist encoding
	existingScore, exists := z.dict[member]
	if exists {
		// If score changed, update both dict and skiplist
		if existingScore != score {
			// Remove from skiplist with old score
			z.skiplist.Delete(member, existingScore)
			// Insert with new score
			z.skiplist.Insert(member, score)
			// Update score in dict
			z.dict[member] = score
		}
		return false
	}
 
	// Add new member to both dict and skiplist
	z.dict[member] = score
	z.skiplist.Insert(member, score)
	return true
}

// Helper function to format score as string
func formatScore(score float64) string {
	return fmt.Sprintf("%f", score)
}

// Convert from listpack to skiplist encoding
func (z *zset) convertToSkiplist() {
	if z.encoding == encodingSkiplist {
		return
	}
 
	// Initialize skiplist and dict
	z.skiplist = skiplist.NewSkipList()
	z.dict = make(map[string]float64, len(z.listpack))
 
	// Transfer all elements from listpack to skiplist and dict
	for _, pair := range z.listpack {
		member := pair[0]
		score, _ := parseScore(pair[1])
		z.dict[member] = score
		z.skiplist.Insert(member, score)
	}
 
	// Update encoding and clear listpack
	z.encoding = encodingSkiplist
	z.listpack = nil
}
 
// Helper function to parse score string to float64
func parseScore(scoreStr string) (float64, error) {
	return strconv.ParseFloat(scoreStr, 64)
}

ZSCORE key member

ZSCORE myzset member1

// execZScore implements the ZSCORE command
// ZSCORE key member
func execZScore(db *DB, args [][]byte) resp.Reply {
	if len(args) != 2 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zscore' command")
	}
 
	key := string(args[0])
	member := string(args[1])
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeNullBulkReply()
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	// Get score
	score, exists := zsetObj.Score(member)
	if !exists {
		return reply.MakeNullBulkReply()
	}
 
	return reply.MakeBulkReply([]byte(strconv.FormatFloat(score, 'f', -1, 64)))
}

type ZSet interface {
    Add(member string, score float64) bool
    Score(member string) (float64, bool)
}
 
// Score returns the score of a member, and a boolean indicating if the member exists
func (z *zset) Score(member string) (float64, bool) {
	if z.encoding == encodingListpack {
		for _, pair := range z.listpack {
			if pair[0] == member {
				score, err := parseScore(pair[1])
				if err != nil {
					return 0, false
				}
				return score, true
			}
		}
		return 0, false
	}
 
	// Using skiplist encoding
	score, exists := z.dict[member]
	return score, exists
}

ZCARD key

ZCARD myzset

// execZCard implements the ZCARD command
// ZCARD key
func execZCard(db *DB, args [][]byte) resp.Reply {
	if len(args) != 1 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zcard' command")
	}
 
	key := string(args[0])
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeIntReply(0)
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	return reply.MakeIntReply(int64(zsetObj.Len()))
}

type ZSet interface {
    Add(member string, score float64) bool
    Score(member string) (float64, bool)
    Len() int
}
 
// Len returns the number of elements in the sorted set
func (z *zset) Len() int {
	if z.encoding == encodingListpack {
		return len(z.listpack)
	}
	return len(z.dict)
}

ZRANGE key start stop [WITHSCORES]

ZRANGE myzset 0 1 WITHSCORES

// execZRange implements the ZRANGE command
// ZRANGE key start stop [WITHSCORES]
func execZRange(db *DB, args [][]byte) resp.Reply {
	if len(args) < 3 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zrange' command")
	}
 
	withScores := false
	if len(args) > 3 && string(args[3]) == "WITHSCORES" {
		withScores = true
	}
 
	key := string(args[0])
 
	// Parse start and stop indices
	start, err := strconv.Atoi(string(args[1]))
	if err != nil {
		return reply.MakeStandardErrorReply("value is not an integer or out of range")
	}
 
	stop, err := strconv.Atoi(string(args[2]))
	if err != nil {
		return reply.MakeStandardErrorReply("value is not an integer or out of range")
	}
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeEmptyMultiBulkReply()
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	// Get range
	members := zsetObj.RangeByRank(start, stop)
 
	// Prepare result
	if !withScores {
		result := make([][]byte, len(members))
		for i, member := range members {
			result[i] = []byte(member)
		}
		return reply.MakeMultiBulkReply(result)
	} else {
		result := make([][]byte, len(members)*2)
		for i, member := range members {
			result[i*2] = []byte(member)
			score, _ := zsetObj.Score(member)
			result[i*2+1] = []byte(strconv.FormatFloat(score, 'f', -1, 64))
		}
		return reply.MakeMultiBulkReply(result)
	}
}

type ZSet interface {
    // ...
    RangeByRank(start, stop int) []string
}
 
// RangeByRank returns members ordered by rank (position)
// Returns members between start and stop ranks (inclusive, 0-based)
func (z *zset) RangeByRank(start, stop int) []string {
	if z.encoding == encodingListpack {
		// Copy and sort listpack elements by score
		pairs := make([][2]string, len(z.listpack))
		copy(pairs, z.listpack)
 
		sort.Slice(pairs, func(i, j int) bool {
			scoreI, _ := parseScore(pairs[i][1])
			scoreJ, _ := parseScore(pairs[j][1])
			return scoreI < scoreJ
		})
 
		// Handle negative indices and out of range
		size := len(pairs)
		if start < 0 {
			start = size + start
		}
		if stop < 0 {
			stop = size + stop
		}
		if start < 0 {
			start = 0
		}
		if stop >= size {
			stop = size - 1
		}
		if start > stop || start >= size {
			return []string{}
		}
 
		// Extract member names
		result := make([]string, 0, stop-start+1)
		for i := start; i <= stop; i++ {
			result = append(result, pairs[i][0])
		}
		return result
	}
 
	// Using skiplist encoding
	return z.skiplist.RangeByRank(start, stop)
}

ZREM key member [member ...]

ZREM myzset member1 member2

// execZRem implements the ZREM command
// ZREM key member [member ...]
func execZRem(db *DB, args [][]byte) resp.Reply {
	if len(args) < 2 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zrem' command")
	}
 
	key := string(args[0])
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeIntReply(0)
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	// Remove members
	removed := 0
	for i := 1; i < len(args); i++ {
		member := string(args[i])
		if zsetObj.Remove(member) {
			removed++
		}
	}
 
	// Update database if we removed anything
	if removed > 0 {
		db.PutEntity(key, &database.DataEntity{Data: zsetObj})
 
		// Add AOF record
		db.addAof(utils.ToCmdLineWithName("ZREM", args...))
	}
 
	return reply.MakeIntReply(int64(removed))
}

type ZSet interface {
    // ...
    Remove(member string) bool
}
 
// Remove removes a member from the sorted set
// Returns true if the member was removed, false if it didn't exist
func (z *zset) Remove(member string) bool {
	if z.encoding == encodingListpack {
		for i, pair := range z.listpack {
			if pair[0] == member {
				// Remove the member by slicing it out
				z.listpack = append(z.listpack[:i], z.listpack[i+1:]...)
				return true
			}
		}
		return false
	}
 
	// Using skiplist encoding
	score, exists := z.dict[member]
	if exists {
		z.skiplist.Delete(member, score)
		delete(z.dict, member)
		return true
	}
	return false
}

ZCOUNT key min max

ZCOUNT myzset 1 2

// execZCount implements the ZCOUNT command
// ZCOUNT key min max
func execZCount(db *DB, args [][]byte) resp.Reply {
	if len(args) != 3 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zcount' command")
	}
 
	key := string(args[0])
 
	// Parse min and max scores
	min, err := parseFloat(string(args[1]))
	if err != nil {
		return err
	}
 
	max, err := parseFloat(string(args[2]))
	if err != nil {
		return err
	}
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeIntReply(0)
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	// Count elements in range
	count := zsetObj.Count(min, max)
 
	return reply.MakeIntReply(int64(count))
}

type ZSet interface {
    // ...
    Count(min, max float64) int
}
 
// Count returns the number of elements in the specified score range
func (z *zset) Count(min, max float64) int {
	if z.encoding == encodingListpack {
		count := 0
		for _, pair := range z.listpack {
			score, _ := parseScore(pair[1])
			if score >= min && score <= max {
				count++
			}
		}
		return count
	}
 
	// Using skiplist encoding
	return z.skiplist.CountInRange(min, max)
} 

ZRANK key member

ZRANK myzset member1

// execZRank implements the ZRANK command
// ZRANK key member
func execZRank(db *DB, args [][]byte) resp.Reply {
	if len(args) != 2 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'zrank' command")
	}
 
	key := string(args[0])
	member := string(args[1])
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeNullBulkReply()
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	// Get member's rank
	score, exists := zsetObj.Score(member)
	if !exists {
		return reply.MakeNullBulkReply()
	}
 
	// Using skiplist's GetRank method
	rank := -1
	if zsetObj.Encoding() == 1 { // Using skiplist encoding
		// We need to access the skiplist from the ZSet implementation
		skiplist := zsetObj.GetSkiplist()
		rank = skiplist.GetRank(member, score)
	} else {
		// For listpack encoding, we need to compute rank by sorting
		members := zsetObj.RangeByRank(0, -1)
		for i, m := range members {
			if m == member {
				rank = i
				break
			}
		}
	}
 
	if rank == -1 {
		return reply.MakeNullBulkReply()
	}
 
	return reply.MakeIntReply(int64(rank))
}

// Encoding returns the current encoding type of the zset (0 for listpack, 1 for skiplist)
func (z *zset) Encoding() int {
	return z.encoding
}
 
// GetSkiplist returns the skiplist used by the zset when in skiplist encoding
// Returns nil if the zset is using listpack encoding
func (z *zset) GetSkiplist() *skiplist.SkipList {
	if z.encoding == encodingSkiplist {
		return z.skiplist
	}
	return nil
}

// Register ZSET commands
func init() {
	RegisterCommand("ZADD", execZAdd, -4)     // key score member [score member ...]
	RegisterCommand("ZSCORE", execZScore, 3)  // key member
	RegisterCommand("ZCARD", execZCard, 2)    // key
	RegisterCommand("ZRANGE", execZRange, -4) // key start stop [WITHSCORES]
	RegisterCommand("ZREM", execZRem, -3)     // key member [member ...]
	RegisterCommand("ZCOUNT", execZCount, 4)  // key min max
	RegisterCommand("ZRANK", execZRank, 3)    // key member
}

type ZSet interface {
	Add(member string, score float64) bool
	Remove(member string) bool
	Score(member string) (float64, bool)
	Exists(member string) bool
	Count(min, max float64) int
	Len() int
	RangeByScore(min, max float64, offset, count int) []string
	RangeByRank(start, stop int) []string
	RemoveRangeByRank(start, stop int) int
	RemoveRangeByScore(min, max float64) int
	Encoding() int
	GetSkiplist() *skiplist.SkipList
}

// ZSet operations
routerMap["zadd"] = defaultFunc   // zadd key score member [score member ...]
routerMap["zscore"] = defaultFunc // zscore key member
routerMap["zcard"] = defaultFunc  // zcard key
routerMap["zrange"] = defaultFunc // zrange key start stop [WITHSCORES]
routerMap["zrem"] = defaultFunc   // zrem key member [member ...]
routerMap["zcount"] = defaultFunc // zcount key min max
routerMap["zrank"] = defaultFunc  // zrank key member

// execZTYPE implements the ZTYPE command
// ZTYPE key returns the type of the key, 0 for listpack, 1 for skiplist
func execZType(db *DB, args [][]byte) resp.Reply {
	if len(args) != 1 {
		return reply.MakeStandardErrorReply("wrong number of arguments for 'ztype' command")
	}
 
	key := string(args[0])
 
	// Get ZSet
	zsetObj, exists := getAsZSet(db, key)
	if !exists {
		return reply.MakeNullBulkReply()
	}
	if zsetObj == nil {
		return reply.MakeWrongTypeErrReply()
	}
 
	return reply.MakeIntReply(int64(zsetObj.Encoding()))
}
 
// Register ZTYPE command
func init() {
    RegisterCommand("ZTYPE", execZType, 2) // key
}

(base) orangejuice@Mac redigo % redis-cli -p 6380
127.0.0.1:6380> ZADD myzset 1 "one"
(integer) 1
127.0.0.1:6380> ZADD myzset 2 "two" 3 "three"
(integer) 2
127.0.0.1:6380> ZCARD myzset
(integer) 3
127.0.0.1:6380> ZSCORE myzset "one"
"1"
127.0.0.1:6380> ZSCORE myzset "two"
"2"
127.0.0.1:6380> ZSCORE myzset "nonexistent"
(nil)
127.0.0.1:6380> ZRANGE myzset 0 -1     
1) "one"
2) "two"
3) "three"
127.0.0.1:6380> ZRANGE myzset 0 1
1) "one"
2) "two"
127.0.0.1:6380> ZRANGE myzset -2 -1
1) "two"
2) "three"
127.0.0.1:6380> ZRANGE myzset 0 -1 WITHSCORES
1) "one"
2) "1"
3) "two"
4) "2"
5) "three"
6) "3"
127.0.0.1:6380> ZREM myzset "two"
(integer) 1
127.0.0.1:6380> ZRANGE myzset 0 -1
1) "one"
2) "three"
127.0.0.1:6380> ZADD myzset 2 "two" 4 "four" 5 "five"
(integer) 3
127.0.0.1:6380> ZCOUNT myzset 2 4
(integer) 3
127.0.0.1:6380> ZRANGE myzset 0 -1
1) "one"
2) "two"
3) "three"
4) "four"
5) "five"

git add .
git commit -m "feat: implement ZSet"
git push origin main