-2

我有

4, 5', 6, 5''

并希望将稳定排序反转为

6, 5', 5'', 4

但不是

6, 5'', 5', 4

此（无效）代码不起作用

keys := []int{4, 5', 6, 5''}
sort.Stable(sort.Reverse(sort.Ints(keys)))

它会产生：

6, 5'', 5', 4

这里的问题显示为简化为整数切片，但实际上我需要将其应用于结构切片

type myStruct struct {
    t time.Time
    d time.Duration
}

t和基于字段的反向稳定排序。

编辑：经过几条评论后，我明确指出整数一是简化问题的无效示例。

4

3 回答 3

2

在切片类型上实现sort.Interface接口，因此您可以选择排序顺序，并对其应用稳定的排序。示例： https: //play.golang.org/p/TWAtH7asi3

于 2017-01-15T20:54:40.020 回答
1

在您的自定义结构上实现sort.Interface接口。

type myStruct struct{
    t time.Time
    d time.Duration
}

type Slice []myStruct

func (s Slice) Len() int {  return len(s) }

func (s Slice) Less(i, j int) bool {
    return (s[i].t).After(s[j].t)
}

func (s Slice) Swap(i, j int) {
    s[i], s[j] = s[j], s[i]
}

在您的情况下，以下函数将根据t

func (s Slice) Less(i, j int) bool {
    return (s[i].t).After(s[j].t)
}

(s[i].t).After(s[j].t)报告是否s[i].t在s[j].t.

如果您只想排序，请使用以下一个

func (s Slice) Less(i, j int) bool {
    return (s[i].t).Before(s[j].t)
}

希望这会有所帮助。

于 2017-01-17T05:37:50.980 回答
0

看来您不需要经历实现排序接口的麻烦。您可以使用sort.Slice或sort.SliceStable对裸机进行排序。

这对我有用（去操场）：

package main

import (
    "fmt"
    "sort"
    "time"
)

func main() {
    layout := "Jan 2 15:04:05 -0700 MST 2006"
    t1, _ := time.Parse(layout, "Jan 2 15:04:05 -0700 MST 2008")
    t2, _ := time.Parse(layout, "Jan 2 15:04:05 -0700 MST 2001")
    t3, _ := time.Parse(layout, "Jan 2 15:04:05 -0700 MST 2003")
    t4, _ := time.Parse(layout, "Jan 2 15:04:05 -0700 MST 2006")

    timestamps := []struct {
        T time.Time
        d time.Duration
    }{
        {t1, 1},
        {t2, 1},
        {t3, 1},
        {t4, 1},
    }

    // forward
    sort.Slice(timestamps, func(i, j int) bool { 
        return timestamps[i].T.Before(timestamps[j].T) 
    })
    fmt.Println("By time:", timestamps)

    // reverse
    sort.Slice(timestamps, func(i, j int) bool { 
        return timestamps[i].T.After(timestamps[j].T) 
    })
    fmt.Println("By time:", timestamps)
}
于 2017-03-08T20:09:04.413 回答