Sorting 如何按其值对Map[string]int进行排序？

给定这个代码块

map[string]int {"hello":10, "foo":20, "bar":20}

我想打印出来

foo, 20
bar, 20
hello, 10

按从高到低的顺序

谢谢

例如：

package main

import (
        "fmt"
        "sort"
)

func main() {
        m := map[string]int{"hello": 10, "foo": 20, "bar": 20}
        n := map[int][]string{}
        var a []int
        for k, v := range m {
                n[v] = append(n[v], k)
        }
        for k := range n {
                a = append(a, k)
        }
        sort.Sort(sort.Reverse(sort.IntSlice(a)))
        for _, k := range a {
                for _, s := range n[k] {
                        fmt.Printf("%s, %d\n", s, k)
                }
        }
}

---

输出：

foo, 20
bar, 20
hello, 10

---

找到了Andrew Gerrand关于Golang nuts的答案

您可以通过编写len/less/swap函数来实现排序接口

func rankByWordCount(wordFrequencies map[string]int) PairList{
  pl := make(PairList, len(wordFrequencies))
  i := 0
  for k, v := range wordFrequencies {
    pl[i] = Pair{k, v}
    i++
  }
  sort.Sort(sort.Reverse(pl))
  return pl
}

type Pair struct {
  Key string
  Value int
}

type PairList []Pair

func (p PairList) Len() int { return len(p) }
func (p PairList) Less(i, j int) bool { return p[i].Value < p[j].Value }
func (p PairList) Swap(i, j int){ p[i], p[j] = p[j], p[i] }

func rankByWordCount（字频率映射[string]int）成对列表{
pl:=make（成对列表，len（字频率））
i:=0
对于k，v:=范围字频率{
pl[i]=对{k，v}
我++
}
sort.sort（sort.Reverse（pl））
返回pl
}
类型对结构{
键串
值int
}
类型PairList[]对
func（p PairList）Len（）int{return Len（p）}
func（p PairList）Less（i，j int）bool{return p[i]。Value

---

对于原始帖子，请在这里找到它

go 1.8中有一个新的sort.Slice函数，因此现在它更简单了

package main

import (
    "fmt"
    "sort"
)

func main() {
    m := map[string]int{
        "something": 10,
        "yo":        20,
        "blah":      20,
    }

    type kv struct {
        Key   string
        Value int
    }

    var ss []kv
    for k, v := range m {
        ss = append(ss, kv{k, v})
    }

    sort.Slice(ss, func(i, j int) bool {
        return ss[i].Value > ss[j].Value
    })

    for _, kv := range ss {
        fmt.Printf("%s, %d\n", kv.Key, kv.Value)
    }
}

---

首先按值对键进行排序，然后迭代映射：

主程序包
进口(
“fmt”
“排序”
)
func main（）{
计数：=map[string]int{“hello”：10，“foo”：20，“bar”：20}
键：=make（[]字符串，0，len（计数））
对于键：=范围计数{
keys=append（键，键）
}
sort.Slice（keys，func（i，j int）bool{return counts[keys[i]]>counts[keys[j]}）
对于u，键：=范围键{
fmt.Printf（“%s，%d\n”，键，计数[键]）
}
}

我经常需要对我正在计算并一直在使用的东西的

映射[string]int

进行排序

func rankMapStringInt（值映射[string]int]string{
kv型结构{
键串
值int
}
无功功率[]千伏
对于k，v:=范围值{
ss=append（ss，kv{k，v}）
}
sort.Slice（ss，func（i，j int）bool{
返回ss[i].Value>ss[j].Value
})
排名：=make（[]字符串，len（值））
对于i，kv:=范围ss{
排名[i]=kv.键
}
回报排名
}

使用它按值的顺序迭代键

values := map[string]int{"foo": 10, "bar": 20, "baz": 1}

for i, index := range rankMapStringInt(values) {
    fmt.Printf("%3d: %s -> %d", i, index, values[index])
}

---

在我的例子中，我正在处理我创建的一个程序。在这个节目中，我 用

string

和

int

创建了一个与您一样的地图。然后我发现我和你一样 Go并没有一个内置的方式来分类这样的东西。我读了报纸 其他答案和我读到的不太喜欢

所以我试着用不同的方式思考这个问题。Go可以使用 吃一片。此外，Go还可以与自定义比较器一起使用。所以 我没有创建

string

和

int

的映射，而是创建了

string

和

int

。然后您可以排序：

package main

import (
   "fmt"
   "sort"
)

type file struct {
   name string
   size int
}

func main() {
   a := []file{
      {"april.txt", 9}, {"may.txt", 7},
   }
   sort.Slice(a, func (d, e int) bool {
      return a[d].size < a[e].size
   })
   fmt.Println(a)
}

主程序包
进口(
“fmt”
“排序”
)
类型文件结构{
名称字符串
大小整数
}
func main（）{
a:=[]文件{
{“april.txt”，9}，{“may.txt”，7}，
}
sort.Slice（a，func（d，e int）bool{
返回a[d]。大小

这不会对每个人都有效，因为也许你会被迫处理这些问题 其他人创建的地图。但这对我很有用。好的部分是，不同于一切

---

其他答案，这一个不使用循环。

。。。除非

Less

返回了错误的结果。对于反向排序，请使用

@larsmans My bad！谢谢你指出这一点。相反，我使用了sort.Reverse来获得反向结果即使更好，我甚至都不知道sort.Reverse+1.@DarshanComputing:谢谢，修复了。这假设值没有标识。@newacct:它只解决OP问题，而不是一般情况；-）这个解决方案也适用于我的案例，简单易懂。我不喜欢输出不是我开始的地图with@hendry这个答案是针对原问题的格式作出的。在go1.12中，您可以只打印地图并对其进行排序，请参阅问题：几乎完美，我建议处理具有相同值的元素。@TommasoBarbugli如何处理？让他们稳定下来？还是按字母顺序排序？非常确定的是，稳定性是不可能的，因为Go会将映射迭代顺序随机化，以阻止您依赖一个对编译器来说不重要的顺序。对于字母顺序，您可以很容易地修改传递给sort.slice的匿名函数。还有一个（在Go 1.8中也添加了）保留相等元素的原始顺序。我很确定是谁在投票，可能是那些没有仔细阅读comparator函数的人。同样被接受的答案并不会产生所要求的打印输出，而是引入了必须在实际代码中维护的新数据结构。这里是我答案的游乐场链接