如何在Go语言中高效地实现有序Map迭代：避免map的局限性

type MyKey int // 假设MyKey是int类型，方便比较
type MyValue string

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

// PairKeyValueSlice 实现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]
}

func (ps PairKeyValueSlice) Less(i, j int) bool {
    // 假设MyKey是可直接比较的，如果MyKey是struct，则需要自定义比较逻辑
    return ps[i].Key < ps[j].Key
}

// NewPairKeyValueSlice 将map转换为有序的键值对切片
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() {
    myMap := map[MyKey]MyValue{
        3: "Apple",
        1: "Banana",
        2: "Cherry",
    }

    // 每次需要有序迭代时，都进行转换和排序
    sortedPairs := NewPairKeyValueSlice(myMap)
    for _, kv := range sortedPairs {
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
    }
}

package main

import (
    "fmt"
    "sort" // 仅用于NewPairKeyValueSlice示例，实际B树用法不需要
    "strconv"

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

// MyKey 和 MyValue 定义
type MyKey int
type MyValue string

// KeyValueItem 结构体用于存储键值对，并实现btree.Item接口
type KeyValueItem struct {
    Key   MyKey
    Value MyValue
}

// Less 方法实现了btree.Item接口，定义了键的比较逻辑
func (kvi KeyValueItem) Less(than btree.Item) bool {
    // 确保类型断言安全
    if other, ok := than.(KeyValueItem); ok {
        return kvi.Key < other.Key
    }
    // 如果类型不匹配，可以根据实际情况处理，例如抛出panic或返回false
    // 这里为了示例简单，假设than总是KeyValueItem类型
    panic("Cannot compare KeyValueItem with a non-KeyValueItem type")
}

func main() {
    // 1. 初始化B树：阶数（degree）决定了每个节点可以存储的键的数量。
    // 阶数越大，树的深度越小，但节点内部查找可能慢一点。通常选择2-32之间。
    tr := btree.New(2) 

    // 2. 插入数据：使用ReplaceOrInsert方法插入键值对
    tr.ReplaceOrInsert(KeyValueItem{Key: 30, Value: "Apple"})
    tr.ReplaceOrInsert(KeyValueItem{Key: 10, Value: "Banana"})
    tr.ReplaceOrInsert(KeyValueItem{Key: 20, Value: "Cherry"})
    tr.ReplaceOrInsert(KeyValueItem{Key: 50, Value: "Date"})
    tr.ReplaceOrInsert(KeyValueItem{Key: 40, Value: "Elderberry"})

    fmt.Println("--- 有序迭代B树 (Ascend) ---")
    // 3. 有序迭代：Ascend方法按升序遍历所有元素
    tr.Ascend(func(item btree.Item) bool {
        kv := item.(KeyValueItem) // 类型断言
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true // 返回true继续迭代，返回false停止迭代
    })

    fmt.Println("\n--- 范围迭代 (AscendGreaterOrEqual, Key >= 25) ---")
    // 4. 范围迭代：AscendGreaterOrEqual 从指定键开始升序迭代
    tr.AscendGreaterOrEqual(KeyValueItem{Key: 25}, func(item btree.Item) bool {
        kv := item.(KeyValueItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true
    })

    fmt.Println("\n--- 降序迭代 (Descend) ---")
    // 5. 降序迭代：Descend方法按降序遍历所有元素
    tr.Descend(func(item btree.Item) bool {
        kv := item.(KeyValueItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true
    })

    // 6. 查找元素
    searchKey := MyKey(20)
    if foundItem := tr.Get(KeyValueItem{Key: searchKey}); foundItem != nil {
        kv := foundItem.(KeyValueItem)
        fmt.Printf("\n--- 查找 Key %d: Value %s ---\n", searchKey, kv.Value)
    } else {
        fmt.Printf("\n--- Key %d 未找到 ---\n", searchKey)
    }

    // 7. 删除元素
    deleteKey := MyKey(30)
    if deletedItem := tr.Delete(KeyValueItem{Key: deleteKey}); deletedItem != nil {
        kv := deletedItem.(KeyValueItem)
        fmt.Printf("\n--- 删除 Key %d: Value %s ---\n", deleteKey, kv.Value)
    } else {
        fmt.Printf("\n--- Key %d 不存在，无法删除 ---\n", deleteKey)
    }

    fmt.Println("\n--- 删除后再次有序迭代 ---")
    tr.Ascend(func(item btree.Item) bool {
        kv := item.(KeyValueItem)
        fmt.Printf("Key: %d, Value: %s\n", kv.Key, kv.Value)
        return true
    })
}