在Go语言中实现有序Map迭代的策略

package main

import (
    "fmt"
    "sort"
)

// MyKey 和 MyValue 可以是任何类型，这里使用简单的int和string作为示例
type MyKey int
type MyValue string

// PairKeyValue 结构体用于存储键值对
type PairKeyValue struct {
    Key   MyKey
    Value MyValue
}

// PairKeyValueSlice 是一个PairKeyValue的切片，实现了sort.Interface接口
type PairKeyValueSlice []PairKeyValue

func (ps PairKeyValueSlice) Len() int {
    return len(ps)
}

func (ps PairKeyValueSlice) Swap(i, j int) {
    ps[i], ps[j] = ps[j], ps[i]
}

// Less 定义了排序规则，这里按MyKey的升序排列
func (ps PairKeyValueSlice) Less(i, j int) bool {
    return ps[i].Key < ps[j].Key // 假设MyKey是可比较的
}

// NewPairKeyValueSlice 从map创建并返回一个已排序的PairKeyValue切片
func NewPairKeyValueSlice(m map[MyKey]MyValue) PairKeyValueSlice {
    ps := make(PairKeyValueSlice, 0, len(m))
    for k, v := range m {
        ps = append(ps, PairKeyValue{Key: k, Value: v})
    }
    sort.Sort(ps) // 对切片进行排序
    return ps
}

func main() {
    // 示例map
    myMap := map[MyKey]MyValue{
        5: "apple",
        2: "banana",
        8: "cherry",
        1: "date",
        3: "elderberry",
    }

    fmt.Println("原始map（无序迭代）：")
    for k, v := range myMap {
        fmt.Printf("Key: %d, Value: %s\n", k, v)
    }

    fmt.Println("\n排序后迭代：")
    // 使用NewPairKeyValueSlice获取有序的键值对切片
    sortedPairs := NewPairKeyValueSlice(myMap)
    for _, kv := range sortedPairs {
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
    }
}

go get github.com/google/btree

package main

import (
    "fmt"
    "github.com/google/btree" // 导入B树库
)

// Item类型需要实现btree.Item接口，即Less方法
type MyBTreeItem struct {
    Key   int
    Value string
}

// Less 实现了btree.Item接口，用于定义MyBTreeItem的比较规则
func (item MyBTreeItem) Less(than btree.Item) bool {
    return item.Key < than.(MyBTreeItem).Key
}

func main() {
    // 创建一个新的B树，参数是每个节点的最大子节点数
    // 较低的值（如2）适用于较小的树，较高的值（如32或64）适用于较大的树
    tr := btree.New(2) 

    // 插入键值对
    tr.ReplaceOrInsert(MyBTreeItem{Key: 5, Value: "apple"})
    tr.ReplaceOrInsert(MyBTreeItem{Key: 2, Value: "banana"})
    tr.ReplaceOrInsert(MyBTreeItem{Key: 8, Value: "cherry"})
    tr.ReplaceOrInsert(MyBTreeItem{Key: 1, Value: "date"})
    tr.ReplaceOrInsert(MyBTreeItem{Key: 3, Value: "elderberry"})

    fmt.Println("B树（有序迭代）：")
    // 使用Ascend方法进行升序遍历
    tr.Ascend(func(item btree.Item) bool {
        kv := item.(MyBTreeItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true // 返回true继续遍历，返回false停止遍历
    })

    fmt.Println("\nB树（降序迭代）：")
    // 使用Descend方法进行降序遍历
    tr.Descend(func(item btree.Item) bool {
        kv := item.(MyBTreeItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true // 返回true继续遍历，返回false停止遍历
    })

    // 查找操作
    searchKey := 3
    if found := tr.Get(MyBTreeItem{Key: searchKey}); found != nil {
        fmt.Printf("\n找到Key %d: Value %s\n", searchKey, found.(MyBTreeItem).Value)
    } else {
        fmt.Printf("\n未找到Key %d\n", searchKey)
    }

    // 删除操作
    tr.Delete(MyBTreeItem{Key: 8})
    fmt.Println("\n删除Key 8后，B树（有序迭代）：")
    tr.Ascend(func(item btree.Item) bool {
        kv := item.(MyBTreeItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true
    })
}