Sorting 按围棋中的v[i]/w[i]对i进行排序的数组

我想按

v[I]/w[I]

对索引数组进行排序，其中

v

和

w

是另外两个整数数组。以下是我在围棋中尝试的内容：

package main
import "fmt"
import "sort"

func main() {
    v := [3]int{5, 6, 3}
    w := [3]int{4, 5, 2}
    indices := make([]int, 3)
    for i := range indices {
        indices[i] = i
    }
    sort.Slice(indices, func(a, b int) bool {
        return float32(v[a])/float32(w[a]) > float32(v[b])/float32(w[b])
    })
    fmt.Println(indices)
}

---

我希望输出是

[2,0,1]

，因为3/2>5/4>6/5，但实际输出是

[0,2,1]

。谁能帮我找到问题出在哪里？谢谢。

发生这种情况是因为排序函数在排序时会更改索引，但伴随的数组v和w保持不变

---

最好的方法是创建一个数组，其中v和w都包含在结构中，然后对该数组进行排序。

这是因为排序函数在排序时会更改索引，但伴随的数组v和w保持不变

---

最好的方法是创建一个数组，其中v和w都包含在一个结构中，然后对该数组进行排序。

按定义排序会移动正在切片中排序的项目，从而更改它们各自的索引。但是，您没有移动正在排序的实际值，它们位于

w

和

v

中，只有

索引

切片

由于

索引

切片包含已排序的“索引”，因此可以使用它查找实际值以进行比较

sort.Slice(indices, func(i, j int) bool {
    return float64(v[indices[i]])/float64(w[indices[i]]) > float64(v[indices[j]])/float64(w[indices[j]])
})

或者，您可以实现一个类型来同时对所有3个值进行排序，例如：

type indexSorter struct {
    indices, w, v []int
}

func (a indexSorter) Len() int { return len(a.indices) }
func (a indexSorter) Swap(i, j int) {
    a.indices[i], a.indices[j] = a.indices[j], a.indices[i]
    a.w[i], a.w[j] = a.w[j], a.w[i]
    a.v[i], a.v[j] = a.v[j], a.v[i]
}
func (a indexSorter) Less(i, j int) bool {
    return float64(a.v[i])/float64(a.w[i]) > float64(a.v[i])/float64(a.w[j])
}

---

按定义排序会移动切片中正在排序的项目，从而更改其各自的索引。但是，您没有移动正在排序的实际值，它们位于

w

和

v

中，只有

索引

切片

由于

索引

切片包含已排序的“索引”，因此可以使用它查找实际值以进行比较

sort.Slice(indices, func(i, j int) bool {
    return float64(v[indices[i]])/float64(w[indices[i]]) > float64(v[indices[j]])/float64(w[indices[j]])
})

或者，您可以实现一个类型来同时对所有3个值进行排序，例如：

type indexSorter struct {
    indices, w, v []int
}

func (a indexSorter) Len() int { return len(a.indices) }
func (a indexSorter) Swap(i, j int) {
    a.indices[i], a.indices[j] = a.indices[j], a.indices[i]
    a.w[i], a.w[j] = a.w[j], a.w[i]
    a.v[i], a.v[j] = a.v[j], a.v[i]
}
func (a indexSorter) Less(i, j int) bool {
    return float64(a.v[i])/float64(a.w[i]) > float64(a.v[i])/float64(a.w[j])
}

---

为了避免变异v和w数组，这可能会很昂贵，我们可以在较少的函数中添加另一个间接级别

sort.Slice(indices, func(a, b int) bool {
        return float32(v[indices[a]])/float32(w[indices[a]]) > float32(v[indices[b]])/float32(w[indices[b]])
    })

---

为了避免变异v和w数组，这可能会很昂贵，我们可以在较少的函数中添加另一个间接级别

sort.Slice(indices, func(a, b int) bool {
        return float32(v[indices[a]])/float32(w[indices[a]]) > float32(v[indices[b]])/float32(w[indices[b]])
    })

---

这里的比较器错误（通过操场上的正确比较器）。你最初的回答也没有描述你在做什么。否则这是一个很好的解决方案。结果我误解了比较函数args的含义（a和b是要比较的项目的索引，而不是要比较的项目）。我认为你被否决了，因为你下错了命令。谢谢你的解决方案，因为它读起来很干净，打字也很简短。你这里的比较器是错误的（通过操场上的更正）。你最初的回答也没有描述你在做什么。否则这是一个很好的解决方案。结果我误解了比较函数args的含义（a和b是要比较的项目的索引，而不是要比较的项目）。我认为你被否决了，因为你下错了命令。谢谢你的解答，因为它读起来很干净，打字也很简短。谢谢你的回答。我应该更仔细地阅读这些文件。谢谢你的回答。我应该更仔细地阅读这些文档。如果不首先使用并行阵列，这会容易得多。它们通常会使事情复杂化。如果不首先使用并行阵列，这会容易得多。他们通常使事情复杂化。