go - 如何在golang中对定长数组进行排序？

Question

我有以下多元数组:

x := [2][3]int{
    {3, 2, 1},
    {3, 2, 1},
}

行和列都是固定大小的。

我正在尝试检查行是否已排序，并且我理解了sort函数需要没有已知大小的数组。我如何要求去将已知大小的固定物品当作未知大小的物品对待？

var allTrue bool = true
for i := range x {
  t := sort.Ints(x[i]) == []int{1, 2, 3}
  allTrue = allTrue && t
}

我得到:

./main.go:xx:yy: sort.Ints(x[i]) used as value
./main.go:xx:yy: cannot use x[i] (type [3]int) as type []int in argument to sort.Ints

我是否正确阅读此错误消息？

Answer 1

尽管有了other answer，它提供了有关使用sort包的适当 slice 的指南，但我添加了此答案，以提供有关您发布的代码的其他更多问题的更多描述。希望这有助于您理解Go语言。

slice 简介

I undertand the sort function requires arrays without a known size [sic]

就像其他人使用 said一样，这不是用Go语言描述此概念的术语。所有的Go数组的大小都是固定的，由 language spec定义。如您所知，数组的类型为 [N]T，其中包含一些类型为 N的元素的非负数 T。这在编译时是固定的，在程序运行时不会改变。

“没有已知大小的数组”最紧密地映射到 slice 。 slice 是Go中不同的类型，可用于表示特定类型的数据序列，其中长度由Go运行时动态管理。对于 []T类型的元素，它们的类型为 T。特别是，它们的大小不是其类型定义的一部分，并且可以在运行时更改。对于某些 slice 变量 x []T，该实现提供了:

一个类似元素类型的内部支持数组，其中实现在 slice 长度增加时管理内存的分配和数组的扩展

其长度len(x) –表示 slice 当前包含

的元素数

的容量cap(x) – slice 的总长度加上支持数组的额外范围，由于 slice 操作限制了数组上的 View 或运行时分配了更大的数组以允许附加更多内容， slice 的总长度可能会超出长度 slice 的项目。

有关更多详细信息，请参见 Tour of Go和 language spec on slices。

用代码解决问题

如上所述， slice 与数组具有不同的类型，因此对于某些需要 [N]T类型的 N和 T，您不能使用 []T类型的东西。
sort.Ints就地对整数 slice 进行排序-它具有类型签名 func Ints(a []int)。您的调用 sort.Ints(x[i])在索引 x处索引了 i数组，这将返回 [3]int类型的数组。这与sort函数不兼容，并导致您观察到编译时错误。

要从数组中获取 slice ，请使用 slice expression。这样的表达式允许使用数组， slice 和其他一些类型来构造新 slice 。

slice 表达式以 a[low : high]的形式给出，其中 low和 high是可选整数，它们提供支持数组或 slice 的索引，这些索引指定了要在新 slice 中返回的范围。上面的语言规范链接提供了更多详细信息，我建议您阅读；足以说出某个数组或 slice a[:]的最简单 slice 表达式 a是表示 a[0:len(a)-1]的语法糖，即将数组/slice 转换为相同长度的 slice 。

使用此技巧，通过 slice ，从多维数组中获取 []int类型的 slice : x[i][:]:

x[i]返回一个[3]int类型的数组，就像

之前一样

对返回的数组进行 slice 将返回[]int类型的 slice ，该 slice 与sort.Ints兼容。

sort.Ints不返回值，并且 slice 不具有可比性

即使使用代码解决了这些问题，以下行仍然存在两个问题:

t := sort.Ints(x[i]) == []int{1, 2, 3}

sort.Ints在原地排序；它不返回值，所以相等性测试毫无意义。

sort.Ints在无法比较的 slice 上运行。除非A == B或A是特殊标识符B，否则无法在A或B是 slice 的情况下调用nil。这是language spec涵盖的一个微妙点。 (此外:请阅读该页面，因为您会注意到数组是可比较的。)

由于您无法使用 ==相等运算符直接比较 slice ，因此验证 slice 的逐元素相等性要求:

slice 具有相同的长度(不同的长度意味着一个 slice 比另一个 slice 具有更多的元素)

一个 slice 的每个索引处的元素与其他 slice 相同。

(我忽略了一个事实，即一个 slice 可能与另一个 slice 具有不同的容量，因为我们只关心元素方式的相等性。)

可以通过循环 slice 中的一个来验证，并验证每个索引处的元素是否与另一个 slice 中的相同索引相对应。此示例代码提供了一个示例( playground link):

package main

import (
    "fmt"
)

func CheckEquality(a, b []int) bool {
    // Slices of dissimilar length are not equal
    if len(a) != len(b) {
        return false
    }

    for i, el := range a {
        if b[i] != el {
            return false
        }
    }

    return true
}

func main() {
    var mySlice = []int{1, 2, 3, 4, 5}
    var mySlice2 = []int{1, 2, 3, 4, 5}   // same as mySlice
    var otherSlice = []int{5, 6, 7, 8, 9} // dissimilar slice
    var longSlice = []int{1, 2, 3, 4, 5, 6, 7, 8, 9}

    fmt.Println(CheckEquality(mySlice, mySlice2))   // Expect true
    fmt.Println(CheckEquality(mySlice, otherSlice)) // Expect false
    fmt.Println(CheckEquality(mySlice, longSlice))  // Expect false
}