Golang不知道大家是否熟悉？今天我将给大家介绍《如何使用 Golang 在结构体切片中查找最常见的整数》，这篇文章主要会讲到等等知识点，如果你在看完本篇文章后，有更好的建议或者发现哪里有问题，希望大家都能积极评论指出，谢谢！希望我们能一起加油进步！

*** 免责声明：我不是专业的开发人员，已经对 golang 进行了大约 8 个月的修改（udemy + youtube），但仍然不知道如何解决如下所示的简单问题..

以下是问题的摘要：

• 我试图从来自解码的 .json 文件（包含字符串“name”和整数“age”）的结构中找到最常见的“age”。

• 之后我需要根据“年龄”的最大出现频率打印“姓名”。

• 根据“年龄”最大出现次数打印的“姓名”需要按字母顺序排序

输入（.json）：

[
{"name": "john","age": 15},
{"name": "peter","age": 12},
{"name": "roger","age": 12},
{"name": "anne","age": 44},
{"name": "marry","age": 15},
{"name": "nancy","age": 15}
]

输出：['约翰'、'玛丽'、'南希']。

解释：因为数据中出现次数最多的年龄是 15（出现了 3 次），所以输出应该是一个字符串数组，其中包含三个人的年龄 姓名，在本例中应为 ['john', 'mary', 'nancy']。

异常：

• 如果有多个“年龄”具有相同的最大出现次数，我需要将数据拆分并将它们打印到不同的数组中（即当“anne”年龄为 12 时，结果为：['john' ，“玛丽”，“南希”]，[“安妮”，“彼得”，“罗杰”]

这是我尝试过的（在 golang 中）：

package main
{
import (
    "encoding/json"
    "fmt"
    "os"
    "sort"
)
// 1. preparing the empty struct for .json
type passanger struct {
    name string `json:"name"`
    age  int    `json:"age"`
}
func main() {
    // 2. load the json file
    content, err := os.readfile("passanger.json")
    if err != nil {
        fmt.println(err.error())
    }
    // 3. parse json file to slice
    var passangers []passanger
    err2 := json.unmarshal(content, &passangers)
    if err2 != nil {
        fmt.println("error json unmarshalling")
        fmt.println(err2.error())
    }
    // 4. find most frequent age numbers (?)
    for _, v := range passangers {
        // this code only show the age on every line
        fmt.println(v.age)
    }
    // 5. print the name and sort them apabethically (?)
       // use sort.slice package
       // implement group based by "max-occurence-age"
}

从昨天开始就被困住了，我也尝试实现许多编码挑战问题的解决方案，例如：

func majorityelement(arr int) int {
    sort.ints(arr)
    return arr[len(arr)/2]
}

但我仍然在努力理解如何将 passanger 切片中的“age”值作为整数输入（arr int）处理到上面的代码。

我在网上找到的其他解决方案是通过迭代 trough map[int]int 来找到最大频率：

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("Frequency of the Array is : ", freq)
}

但是，.json 文件不仅包含整数（年龄），还包含字符串（名称）格式，我仍然不知道如何分别处理“名称”和“年龄”..

我真的需要适当的指导。

*** 这是我上面提到的源代码 (main.go) 和 (.json) 文件： https://github.com/ariejanuarb/golang-json

正确答案

实施解决方案之前需要做什么

在我大学的第一年，我的老师总是向我和我的同学重复一些事情，不要先写代码，特别是如果你是初学者，请按照以下步骤操作：

• 写下您希望发生的事情
• 将问题详细化为小步骤
• 写出分支时的所有场景和案例
• 编写输入和输出（方法/函数签名）
• 检查它们是否合适

让我们按照以下步骤操作...

写下你想要发生的事情

您已经很好地定义了您的问题，因此我将跳过此步骤。

让我们进一步详细说明

1. 您有乘客名单
2. 您想按乘客的年龄对乘客进行分组
3. 您想查看哪些最常见/乘客最多。
4. 您想按字母顺序打印姓名

分支

• 场景一：一组的规模比其他组的规模大。
• 场景二：两个或多个组大小相同且比其他组大。

可能还有更多场景，但你可以找到它们

输入输出??

现在我们已经找到了必须做什么，我们将检查每个步骤的输入和输出以实现此目标。

步骤：

1. 您有乘客名单

• 输入 => 无或文件名（字符串）
• 输出 => []乘客

1. 您想按乘客的年龄对乘客进行分组

• input => []passenger // 乘客列表
• output => map[int][]int 或 map[int][]&passenger // 年龄组

第一种，括号里面的是整个群体的年龄。

第二种类型是包含以下任一内容的列表：

• 乘客在列表中的位置
• 物体/乘客在内存中的地址

只要我们可以轻松地从列表中检索乘客而无需再次迭代即可，这并不重要。

1. 您想查看哪些最常见/乘客最多。

• 输入 => 组（年龄组）

所以这里我们有场景 1 和 2 分支...这意味着它必须对所有场景都有效或者使用条件来分支它们。

• 场景 1 的输出 => 最常见年龄 (int)
• 场景 2 的输出 => 最常见年龄 ([]int)

我们可以看到场景 1 的输出可以与场景 2 的输出合并

1. 您想要按字母顺序打印一个列表中所有乘客的姓名 年龄组

   • 输入 => 群组 ([]乘客) + 年龄 ([]int) + 乘客列表 ([]乘客)。
   • 输出=>字符串或[]字节或什么都没有，如果你只是打印它......

   说实话，如果你想的话，你可以跳过这个。

检查后，开始编码

让我们首先创建符合我们签名的函数

type passenger struct {
    name string `json:"name"`
    age  int    `json:"age"`
}

func getpassengerlist() []passenger{
   // 2. load the json file
   content, err := os.readfile("passanger.json")
   if err != nil {
       fmt.println(err.error())
   }

   // 3. parse json file to slice
   var passengers []passenger
 
   err2 := json.unmarshal(content, &passengers)
   if err2 != nil {
       fmt.println("error json unmarshalling")
       fmt.println(err2.error())
   }

   return passengers
}

// 4a. group by age
func groupbyage(passengers []passenger) map[int][]int {
    group := make(map[int][]int, 0)

    for index, passenger := range passengers {
        agegroup := group[passenger.age]
        agegroup = append(agegroup, index)
        group[passenger.age] = agegroup
    }

    return group
}

// 4b. find the most frequent age numbers

func findmostcommonage(agegroups map[int][]int) []int {
    mostfrequentages := make([]int, 0)
    biggestgroupsize := 0

    // find most frequent age numbers
    for age, agegroup := range agegroups {
        // is most frequent age
        if biggestgroupsize < len(agegroup) {
            biggestgroupsize = len(agegroup)
            mostfrequentages = []int{age}
        } else if biggestgroupsize == len(agegroup) { // is one of the most frequent age
            mostfrequentages = append(mostfrequentages, age)
        }
        // is not one of the most frequent age so does nothing
    }

    return mostfrequentages
}

func main() {
    passengers := loadpassengers()

    // i am lazy but if you want you could sort the
    // smaller slice before printing to increase performance
    sort.slice(passengers, func(i, j int) bool {
        if passengers[i].age == passengers[j].age {
            return passengers[i].name < passengers[j].name
        }
        return passengers[i].age < passengers[j].age
    })

    // age => []position
    // length of the array count as the number of occurences
    agegrouper := groupbyage(passengers)

    mostfrequentages := findmostcommonage(agegrouper)

    // print the passenger
    for _, age := range mostfrequentages {
        fmt.println("{")
        for _, passengerindex := range agegrouper[age] {
            fmt.println("\t", passengers[passengerindex].name)
        }
        fmt.println("}")
    }
}

应该比

• 按年龄和名称对源切片进行排序
• 将其分解为具有共同年龄的序列，并且
• 在进行过程中，跟踪最常见的内容

类似这样的事情：

https://goplay.tools/snippet/6pCpkTEaDXN

type person struct {
    age  int
    name string
}

func mostcommonage(persons []person) (mostcommonage int, names []string) {
  
  sorted := make([]person, len(persons))
  copy(sorted, persons)
  
  // sort the slice by age and then by name
  sort.slice(sorted, func(x, y int) bool {
    left, right := sorted[x], sorted[y]
    
    switch {
    case left.age < right.age:
      return true
    case left.age > right.age:
      return false
    default:
      return left.name < right.name
    }
  })

  updatemostcommonage := func(seq []person) (int, []string) {
    
    if len(seq) > len(names) {
      
      buf := make([]string, len(seq))
      for i := 0; i < len(seq); i++ {
        buf[i] = seq[i].name
      }
      
      mostcommonage = seq[0].age
      names = buf
      
    }

    return mostcommonage, names
  
  }

  for lo, hi := 0, 0; lo < len(sorted); lo = hi {
    
    for hi = lo; hi < len(sorted) && sorted[lo].age == sorted[hi].age; {
      hi++
    }
    
    mostcommonage, names = updatemostcommonage(sorted[lo:hi])
    
  }

  return mostcommonage, names
}

另一种方法使用更多内存，但更简单一些。在这里，我们按年龄构建一个姓名映射，然后对其进行迭代以查找具有最长姓名列表的键。

https://goplay.tools/snippet/_zmMys516IM

type Person struct {
    Age  int
    Name string
}

func MostCommonAge(persons []Person) (mostCommonAge int, names []string) {
    namesByAge := map[int][]string{}

    for _, p := range persons {
        value, found := namesByAge[p.Age]
        if !found {
            value = []string{}
        }
        namesByAge[p.Age] = append(value, p.Name)
    }

    for age, nameList := range namesByAge {
        if len(nameList) > len(names) {
            mostCommonAge, names = age, nameList
        }
    }

    return mostCommonAge, names
}

理论要掌握，实操不能落！以上关于《如何使用 Golang 在结构体切片中查找最常见的整数》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注golang学习网公众号吧！