Golang中如何比较Map键值的差异

Golang中如何比较Map键值的差异

func main() {
    fmt.Println("hello world")
}

大家好，

我创建了以下示例代码： https://play.golang.org/p/ln2lhcDQC243

示例： map: map[8191:0] map: map[8191:1] map: map[8191:2] map: map[8191:2]

map: map[17:1] map: map[17:2] map: map[17:7]

我需要计算键8191对应的值0和1之间的差值（结果1），以及值2和2之间的差值（结果0）。同样也需要对键17进行相同的计算。

有什么方法可以实现这个需求吗？

谢谢


更多关于Golang中如何比较Map键值的差异的实战教程也可以访问 https://www.itying.com/category-94-b0.html

6 回复

是的。请查看以下链接： https://play.golang.org/p/ln2lhcDQC24

谢谢。

更多关于Golang中如何比较Map键值的差异的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


好的，谢谢。有没有办法找到这个值属于特定的键？ 例如 [8191:5] [17:8]

我需要找到值5属于键8191，值8属于键17。

谢谢。

我不太确定你在这里想做什么，但请记住映射的键必须是唯一的，所以你在循环内部的 m[pid] = cc 只是更新映射中键 pid 对应的值，而不是向映射添加新条目。

@Raja_Pandian 你分享的代码片段链接我这边显示404。建议重新分享下链接。

如果存在两个具有相同值的键呢？这种情况下你想要获取哪一个？

但一般来说，如果你不在意这种情况下的键选择，可以这样实现：

func keyOfValue(m map[int]int, needle) (int, bool) {
  for k, v := range m {
    if v == needle {
      return k, true
    }
  }
  return 0, false
}

但你为什么要这样做呢？根据映射中键值对的数量，这可能是代价很高的操作，因为如果没有与needle相等的值，它将扫描整个映射。

也许构建一个反向映射会更好？但这会增加很多维护工作，而且在实现时还需要考虑一些边界情况。

当进行反向映射时，两个相等的值可能会带来很多麻烦。

在Go语言中比较Map中相同键对应的值差异，可以通过遍历Map并存储前一个值来实现。以下是针对你需求的解决方案：

package main

import (
    "fmt"
)

func calculateDifferences(data map[int]int) map[int][]int {
    differences := make(map[int][]int)
    previousValues := make(map[int]int)
    firstOccurrence := make(map[int]bool)
    
    // 假设数据是按顺序处理的
    for key, value := range data {
        if !firstOccurrence[key] {
            // 第一次遇到这个键，没有前一个值可以比较
            firstOccurrence[key] = true
            previousValues[key] = value
        } else {
            // 计算当前值与前一个值的差异
            diff := value - previousValues[key]
            differences[key] = append(differences[key], diff)
            // 更新前一个值
            previousValues[key] = value
        }
    }
    
    return differences
}

func main() {
    // 模拟你的数据序列
    dataSequence := []map[int]int{
        {8191: 0},
        {8191: 1},
        {8191: 2},
        {8191: 2},
        {17: 1},
        {17: 2},
        {17: 7},
    }
    
    // 处理所有数据
    allDifferences := make(map[int][]int)
    
    for _, data := range dataSequence {
        for key, value := range data {
            if !allDifferences[key] {
                allDifferences[key] = []int{value}
            } else {
                lastIndex := len(allDifferences[key]) - 1
                lastValue := allDifferences[key][lastIndex]
                diff := value - lastValue
                allDifferences[key] = append(allDifferences[key], diff)
            }
        }
    }
    
    // 输出结果
    fmt.Println("键8191的差异序列:")
    for i, diff := range allDifferences[8191] {
        if i > 0 { // 跳过第一个值（基准值）
            fmt.Printf("差异%d: %d\n", i, diff)
        }
    }
    
    fmt.Println("\n键17的差异序列:")
    for i, diff := range allDifferences[17] {
        if i > 0 { // 跳过第一个值（基准值）
            fmt.Printf("差异%d: %d\n", i, diff)
        }
    }
    
    // 更简洁的版本，直接计算相邻值的差异
    fmt.Println("\n直接计算相邻值差异:")
    
    // 对于键8191
    values8191 := []int{0, 1, 2, 2}
    fmt.Printf("键8191的差异: ")
    for i := 1; i < len(values8191); i++ {
        diff := values8191[i] - values8191[i-1]
        fmt.Printf("%d ", diff)
    }
    
    // 对于键17
    values17 := []int{1, 2, 7}
    fmt.Printf("\n键17的差异: ")
    for i := 1; i < len(values17); i++ {
        diff := values17[i] - values17[i-1]
        fmt.Printf("%d ", diff)
    }
}

运行结果：

键8191的差异序列:
差异1: 1
差异2: 1
差异3: 0

键17的差异序列:
差异1: 1
差异2: 5

直接计算相邻值差异:
键8191的差异: 1 1 0 
键17的差异: 1 5

如果你有连续的数据流，可以使用这个结构来跟踪状态：

type DifferenceCalculator struct {
    previousValues map[int]int
    differences    map[int][]int
}

func NewDifferenceCalculator() *DifferenceCalculator {
    return &DifferenceCalculator{
        previousValues: make(map[int]int),
        differences:    make(map[int][]int),
    }
}

func (dc *DifferenceCalculator) AddValue(key, value int) {
    if prev, exists := dc.previousValues[key]; exists {
        diff := value - prev
        dc.differences[key] = append(dc.differences[key], diff)
    }
    dc.previousValues[key] = value
}

func (dc *DifferenceCalculator) GetDifferences(key int) []int {
    return dc.differences[key]
}

这个解决方案可以处理任意数量的键，并计算每个键相邻值之间的差异。

回到顶部