Question

我正在尝试以按键存储的值的递减顺序遍历地图。我试过了：

func frequencySort(s string) string {
  var frequency map[string]int
  chararray := strings.Split(s , "")
  var a []int
  var arranged map[int]string
  for k , v := range frequency {
      arranged[v] = k
  }
  for k := range arranged {
      a = append(a , k)
  }
  sort.Sort(sort.Reverse(sort.IntSlice{a}))
}

假设地图结构是：

    "a" : 9
    "b" : 7
    "c" : 19
    "d" : 11

我试图遍历它，输出是：

"c" : 19
"d" : 11
"a" : 9
"b" : 7

Answer 1

例如，

package main

import (
    "fmt"
    "sort"
)

type frequncy struct {
    c string
    f int
}

func frequencies(s string) []frequncy {
    m := make(map[string]int)
    for _, r := range s {
        m[string(r)]++
    }
    a := make([]frequncy, 0, len(m))
    for c, f := range m {
        a = append(a, frequncy{c: c, f: f})
    }
    sort.Slice(a, func(i, j int) bool { return a[i].f > a[j].f })
    return a
}

func main() {
    s := "aaaaabcbcbcbzxyyxzzsoaz"
    fmt.Println(s)
    f := frequencies(s)
    fmt.Println(f)
}

游乐场：https://play.golang.org/p/d9i3yL1x4K

输出：

aaaaabcbcbcbzxyyxzzsoaz
[{a 6} {b 4} {z 4} {c 3} {x 2} {y 2} {s 1} {o 1}]

Answer 2

如果frequency中有多个具有相同值的键，例如"a":7和"b":7，那么您的示例中的两种地图方法就会中断，那么您就会丢失arranged中的数据，因为密钥必须是唯一的。

为避免这种情况，您可以创建一个辅助类型，暂时保存地图的内容，仅用于排序目的。像这样：

package main

import (
    "fmt"
    "sort"
)

var m = map[string]int{
    "a": 9,
    "b": 7,
    "c": 19,
    "d": 11,
}

type entry  struct {
    val int
    key string
}

type entries []entry

func (s entries) Len() int { return len(s) }
func (s entries) Less(i, j int) bool { return s[i].val < s[j].val }
func (s entries) Swap(i, j int) { s[i], s[j] = s[j], s[i] }

func main() {
    var es entries
    for k, v := range m {
        es = append(es, entry{val: v, key: k})
    }

    sort.Sort(sort.Reverse(es))

    for _, e := range es {
        fmt.Printf("%q : %d\n", e.key, e.val)   
    }
}

https://play.golang.org/p/TPb0zNCtXO

以值的递减顺序遍历地图（Golang）

2 个答案: