在Golang中使用地图

I am new to Go and doing a few exercises. One of them is to sort the numbers in an array by frequency, from most to least frequent.

Example: 
Input: [2, 2, 5, 7, 4, 4, 4, 7, 2]
Output: [2, 4, 7, 5]

Note that [4, 2, 7, 5] would also be correct, since 4 and 2 have the same frequency.

For this purpose I am converting the array into a value value map, which here would look like this: [2:3][4:3][7:2][5:1] (2 and 3 have freq. of 3, 7 has the freq of 2,... )

Afterwards I would like to simply loop through the map and output the keys ordered by value. For that I use the following code, which apparently does not work. Why?

count := 0
max := -1

// break loop, if map is empty
for i := 0; i < 1; i-- {
    if len(m) == 0 {
        break
    }

    max = -1

    // get key of biggest value
    for k, v := range m {
        if v > max {
            max = k
        }
    }
    // res (for result) is a slice of integers
    res[count] = max
    // remove key-value-pair from map
    delete(m, max)
    count++
}
return res

Please keep in mind that this is an exercise. I am very sure there are much better, build in ways to do this.

Your 'max' variable is meant to keep track of the maximum frequency seen so far. However when you do 'max = k' you're assigning a key.

You need to keep track of the maximum frequency and the key associated with that frequency in separate variables.

...
for k, v := range m {
    if v > maxFreq {
        maxFreq = v
        mostFrequentKey = k
    }
}
// res (for result) is a slice of integers
res[count] = mostFrequentKey
// remove key-value-pair from map
delete(m, mostFrequentKey)
count++
...

For sorted frequencies, use a map then a slice. For example,

package main

import (
    "fmt"
    "sort"
)

func main() {
    Input := []int{2, 2, 5, 7, 4, 4, 4, 7, 2}
    fmt.Println("Input:      ", Input)
    mFreq := make(map[int]int, len(Input))
    for _, n := range Input {
        mFreq[n]++
    }
    sFreq := make([][2]int, 0, len(mFreq))
    for n, f := range mFreq {
        sFreq = append(sFreq, [2]int{n, f})
    }
    sort.Slice(sFreq, func(i, j int) bool {
        if sFreq[i][1] <= sFreq[j][1] {
            if sFreq[i][1] < sFreq[j][1] {
                return false
            }
            if sFreq[i][0] >= sFreq[j][0] {
                return false
            }
        }
        return true
    },
    )
    Output := []int{2, 4, 7, 5}
    fmt.Println("Output:     ", Output)
    fmt.Println("Frequencies:", sFreq)
}

Playground: https://play.golang.org/p/8tiSksz3S76

Output:

Input:       [2 2 5 7 4 4 4 7 2]
Output:      [2 4 7 5]
Frequencies: [[2 3] [4 3] [7 2] [5 1]]