如何使用 Golang 在结构体切片中查找最常见的整数

检查后，开始编码

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

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 在结构体切片中查找最常见的整数》的详细介绍，大家都掌握了吧！如果想要继续提升自己的能力，那么就来关注编程网公众号吧！