Golang 查找数组中每个元素的频率的程序

给定某个特定数据类型的数组，我们想要查找该数组中元素的频率（出现次数）。我们可以通过在Golang中使用映射来实现。通过创建一个具有整数的特定数据类型映射，我们可以迭代给定的数组并将计数添加到key中作为该元素在数组中的频率。

整型数组

假设我们有一个定义的n个元素的整数数组，我们只需使用映射将元素与其数组中的频率进行映射。首先，我们将定义一个数组，它可以根据程序的使用情况生成或从用户输入。在这里，我们将手动填充数组，仅用于理解实现。在我们拥有整数数组之后，我们可以创建一个将整数映射到整数的映射，由于我们有一个整数数组，因此映射中的键将是数组的元素，而值将是该元素的频率/计数。

freq := make(map[int]int)

可以使用make创建映射。只需为要创建的映射编写键类型和值类型即可。

创建空映射后，我们可以遍历整数数组并将其键设置为频率。默认情况下，第一次出现的键的频率设置为零，因此我们可以在第一次访问数组中的元素时将其增加1。

for _ , num := range arr {

freq[num] = freq[num]+1

}

空标识符(_)只是数组的索引，而num是该索引处的元素，因此我们可以在数组范围内即数组中元素的数量上进行迭代。我们将num用作键，该键是数组中的元素，而map[num]用作键的值。因此，我们为每个唯一的元素（键）递增其值1。

下面是完整的程序。

// 找到整数数组的频率的Go程序
package main

import "fmt"

func main(){
    arr := []int{90, 70, 30, 30, 10, 80, 40, 50, 40, 30}
    freq := make(map[int]int)
    for _ , num :=  range arr {
        freq[num] = freq[num]+1
    }
    fmt.Println("数组的频率为：", freq)
} 

输出：

数组的频率为：map[10:1 30:3 40:2 50:1 70:1 80:1 90:1]

因此，我们可以看到创建了一个频率图，该图将数组中的元素映射到其出现频率。

转换为函数形式

我们甚至可以将逻辑转换为函数，为给定的整数数组创建频率映射。我们只需要将数组解析为参数，返回类型作为带有整数的映射的函数头。为创建频率映射和使用元素和它们的频率填充键和值，逻辑保持不变。

// 将逻辑转换为函数的Go程序
package main

import "fmt"

func main(){
    arr := []int{90, 70, 30, 30, 10, 80, 40, 50, 40, 30}
    freq_map := frequency_map(arr)
    fmt.Println("数组的频率为：", freq_map)
}

func frequency_map( arr []int) map[int]int{
    freq := make(map[int]int)
    for _ , num :=  range arr {
        freq[num] = freq[num]+1
    }
    return freq
} 

输出：

数组的频率为：map[10:1 30:3 40:2 50:1 70:1 80:1 90:1]

因此，我们能够使用Golang中的映射为整数数组创建频率映射。

字符串

假设我们有一个字符串，我们想为字符串中的每个字符创建一个频率计数。在这种情况下，我们将创建一个从字符串到整数的映射，我们将字符串中的每个字符存储为字符串，因为这样方便显示内容，并将该字符串字符的计数存储为映射中的值。

注意： 我们甚至可以使用rune或byte类型代替字符串键，但问题在于它显示Unicode / ASCII代码作为键，而不是字符串本身。

首先定义一个字符串。与整数映射类似，我们将创建一个将字符串映射到整数的映射，如下所示：

freq := make(map[string]int)

创建映射后，我们只需逐个字符地迭代字符串并增加键的值，这里键是字符串的字符。我们将字符（字节/符文）类型连接为字符串，只是因为它方便人类阅读映射。但是您可以将其保留为它是，那么您可能必须更改映射的键类型为：

freq := make(map[byte]int) 或freq := make(map[rune]int)

这将创建一个将字符串中的字符的Unicode值作为键存储的映射。

然后，我们遍历字符串并按以下方式递增字符串中字符键的值：

for _, char := range word {

freq[string(char)] = freq[(char)]+1

}

因此，最终结合各个部分，我们有一个脚本，它接受一个字符串，并将每个字符（字符串类型）映射为键，并将其在映射中作为值的频率。

// 将字符串转换为映射的Go程序
package main
 
import "fmt"
 
func main() {
    arr := "geeksforgeeks"
 
    freq := make(map[string]int)
 
    for _, char := range arr {
        freq[string(char)] = freq[string(char)] + 1
    }
 
    fmt.Println("Array的频率是：", freq)
} 

输出：

Array的频率是：map[e:4 f:1 g:2 k:2 0:1 r:1 s:2]

因此，我们可以看到我们得到了给定字符串中的每个唯一字符的映射，其在整个字符串中的出现频率或计数。

使用符文/字节作为映射中的键

此外，如果我们使用rune/byte数据类型创建映射而不将字符连接为字符串，我们将得到以下输出：

// 使用符文/字节作为映射中的键的Go程序
package main
 
import "fmt"
 
func main() {
    arr := "geeksforgeeks"
 
    freq := make(map[rune]int)
 
    for _, char := range arr {
        freq[char] = freq[char] + 1
    }
 
    fmt.Println("Array的频率是：", freq)
} 

输出：

Array的频率是：map[101:4 102:1 103:2 107:2 111:1 114:1 115:2]

字节的输出相同，但不接受不在ASCII（0到255）代码中的字符，因此在字符值集合上受到限制。如果值超出了字节的范围，字节会产生编译错误。在Go语言中，默认选择的字符值为符文。但是，如果您想在映射中使用字节作为键，您可以在声明中指定它，与符文一样，因此您还需要与字节连接。

package main
 
import "fmt"
 
func main(){
    arr := "geeksforgeeks"
 
    freq := make(map[byte]int)
 
    for _ , char :=  range arr {
        freq[byte(char)] = freq[byte(char)]+1
    }
 
    fmt.Println("Frequency of Array is : ", freq)
} 

输出:

Frequency of Array is : map[101:4 102:1 103:2 107:2 111:1 114:1 115:2]

转化为函数

可以将过程化的代码转换成函数方法，通过创建函数来计算字符串中字符的频率计数。

// Go程序，转化为函数
package main
 
import "fmt"
 
func main(){
    arr := "geeksforgeeks"
    freq_map := frequency_map(arr)
    fmt.Println("Frequency of Array is : ", freq_map)
}
 
func frequency_map(arr string) map[string]int{
    freq := make(map[string]int)
    for _ , char :=  range arr {
        freq[string(char)] = freq[string(char)]+1
    }
    return freq
} 

输出:

Frequency of Array is : map[e:4 f:1 g:2 k:2 o:1 r:1 s:2]

因此，函数frequency_map返回了一个字符串到整数的映射map。通过将字符串解析到该函数中并将频率存储在变量中，我们能够获得字符串的频率图。