Sorting Golang分拣包-模糊分拣错误

我试图修改标准的排序方法，并在排序较少的界面中添加一定的随机性。 什么时候

---

if（u[i]-u[j]）据我所知，Go排序实现需要两个负比较，例如
Less（i，j）
和
Less（j，i）
都返回false，它将其视为相等，但不为正。例如
Less（i，j）
和
Less（j，i）
不能同时返回true。所以，您可以通过逻辑正确和确定性的方式轻松实现所需的结果，只要

if (u[i] - u[j]) < -1 {
        return true
    } else {
        return false
    }

if（u[i]-u[j]）<-1{
返回真值
}否则{
返回错误
}

从Go 1.8开始，有一种更简单的方法可以对切片进行排序，而不需要定义新类型。您只需创建一个较小（匿名）的lambda

a:=[]int{5,3,4,7,8,9}
sort.Slice（a，func（i，j int）bool{
返回a[i]

这将按升序排序，如果您想要相反的顺序，只需编写
a[i]
Less方法必须是确定性的，即为相同的2个值调用Less必须始终产生相同的结果。模糊输出，而不是修改Less函数。理论上，我完全同意。从技术上讲，你的意思是这将以某种方式强制执行吗？Ie-你是说使用不确定的
Less（）
会/会引起恐慌吗？@BrianGerard是的，假设排序是确定的。@Y01rY5Ogfl:随机排序比较器是添加随机性的不正确方法。这引入了非预期的偏差（请参阅以获得良好的可视化效果）以及可能（如此处所示）完全意外的行为。
if u[i] < u[j]

if (u[i] - u[j]) <= rv

package main
import ( 
    "crypto/rand"
    "fmt"
    "math/big"
    "sort"
)

type FuzzySorter []float64

func (u FuzzySorter) Len() int {
    return len(u)
}
func (u FuzzySorter) Swap(i, j int) {
    u[i], u[j] = u[j], u[i]
}
func (u FuzzySorter) Less(i, j int) bool {
    pom, _ := rand.Int(rand.Reader, big.NewInt(int64(2)))
    rv := float64(pom.Int64())
    if (u[i] - u[j]) <= rv {
        return true
    } else {
        return false
    }

}
func (u FuzzySorter) Sort() FuzzySorter {
    sort.Sort(u)
    return u
}

func main() {
    unsorted := FuzzySorter{
        0,
        1,
        1,
        1,
        1,
        6,
        0,
        4,
        6,
        1,
        1,
        1,
        0,
        2,
        8,
        1,
        5,
        4,
        6,
        6,
        6,
        16,
        12,
        6,
        1,
        1,
        1,
        0,
        0,
        11,
        2,
        14,
        16,
        6,
        12,
        0,
        4,
        1,
        0,
        16,
        2,
        6,
        0,
        0,
        0,
        0,
        1,
        11,
        1,
        0,
        2,
        1,
        1,
        1,
        1,
        0,
        1,
        12,
        10,
        1,
        5,
        2,
        6,
        4,
        1,
        0,
        0,
        11,
        1,
        1,
        2,
        2,
        1,
        0,
        0,
        1,
        0,
        1,
        17,
        2,
        1,
        1,
        2,
        0,
        3,
        7,
        1,
        5,
        1,
        0,
        1,
        0,
        0,
        0,
        1,
        3,
        1,
        1,
        1,
        2,
        1,
        0,
        3,
        1,
        6,
        1,
        1,
        0,
        1,
        12,
        0,
        1,
        1,
        0,
        1,
        0,
        0,
        6,
        1,
        2,
        2,
        0,
        0,
        2,
        1,
        1,
        0,
        4,
        4,
        1,
        1,
        1,
        0,
        1,
        1,
        1,
        2,
        0,
        0,
        1,
        0,
        1,
        2,
        1,
        2,
        1,
        1,
        0,
        0,
        4,
        1,
        0,
        1,
        0,
        1,
        1,
        3,
        1,
        0,
    }
    unsorted.Sort()
    fmt.Println(unsorted)

}

panic: runtime error: index out of range

goroutine 1 [running]:
panic(0x176ba0, 0x1040a010)
    /usr/local/go/src/runtime/panic.go:464 +0x700
main.FuzzySorter.Less(0x10456000, 0x9f, 0x9f, 0x19, 0xffffffff, 0x4, 0x1, 0xd)
    /tmp/sandbox201242525/main.go:21 +0x140
main.(*FuzzySorter).Less(0x10434140, 0x19, 0xffffffff, 0x5c, 0x1, 0x10434140)
    <autogenerated>:3 +0xc0
sort.doPivot(0xfef741b0, 0x10434140, 0x19, 0x9f, 0x7, 0x19)
    /usr/local/go/src/sort/sort.go:128 +0x280
sort.quickSort(0xfef741b0, 0x10434140, 0x19, 0x9f, 0xe, 0xfef741b0)
    /usr/local/go/src/sort/sort.go:195 +0xa0
sort.Sort(0xfef741b0, 0x10434140)
    /usr/local/go/src/sort/sort.go:229 +0x80
main.FuzzySorter.Sort(0x10456000, 0x9f, 0x9f, 0x1, 0x0, 0x0, 0x0, 0x1777a0)
    /tmp/sandbox201242525/main.go:29 +0xa0
main.main()
    /tmp/sandbox201242525/main.go:195 +0xc0

if (u[i] - u[j]) < -1 {
        return true
    } else {
        return false
    }

a := []int{5, 3, 4, 7, 8, 9}
sort.Slice(a, func(i, j int) bool {
    return a[i] < a[j]
})
for _, v := range a {
    fmt.Println(v)
}