Go语言中等效类型切片的优雅转换与自定义排序实现

type Job struct {
    weight int
    length int
}

import "sort"

// JobSlice 是一个 []Job 的别名，用于实现 sort.Interface 接口
type JobSlice []Job

// Len 返回切片的长度
func (js JobSlice) Len() int {
    return len(js)
}

// Less 比较两个 Job 的 length 字段，用于升序排序
func (js JobSlice) Less(i, j int) bool {
    return js[i].length < js[j].length
}

// Swap 交换切片中两个 Job 的位置
func (js JobSlice) Swap(i, j int) {
    js[i], js[j] = js[j], js[i]
}

// MinCompletionTimes 根据 Job 的 length 字段对切片进行升序排序
func MinCompletionTimes(jobs []Job) []Job {
    // 这里需要将 []Job 转换为 JobSlice 类型才能使用 sort.Sort
    // 错误的尝试：sort.Sort([]JobSlice(jobs))
    // 正确的转换方式：JobSlice(jobs)
    sort.Sort(JobSlice(jobs))
    return jobs
}

// 假设 jobs 是 []Job 类型
// sort.Sort([]JobSlice(jobs)) // 编译错误：cannot convert jobs (type []Job) to type []JobSlice

// 假设 jobs 是 []Job 类型
sort.Sort(JobSlice(jobs)) // 正确：将 []Job 转换为 JobSlice

package main

import (
    "fmt"
    "sort"
)

// Job 结构体定义
type Job struct {
    ID     string
    weight int
    length int
}

// JobSlice 是 []Job 的别名，用于实现 sort.Interface 接口
type JobSlice []Job

// Len 返回切片的长度
func (js JobSlice) Len() int {
    return len(js)
}

// Less 比较两个 Job 的 length 字段，用于升序排序
func (js JobSlice) Less(i, j int) bool {
    return js[i].length < js[j].length
}

// Swap 交换切片中两个 Job 的位置
func (js JobSlice) Swap(i, j int) {
    js[i], js[j] = js[j], js[i]
}

// MinCompletionTimes 根据 Job 的 length 字段对切片进行升序排序
func MinCompletionTimes(jobs []Job) []Job {
    // 将 []Job 类型的 jobs 转换为 JobSlice 类型，然后进行排序
    sort.Sort(JobSlice(jobs))
    return jobs
}

func main() {
    // 原始 Job 切片
    jobs := []Job{
        {"A", 10, 5},
        {"B", 5, 2},
        {"C", 8, 8},
        {"D", 12, 3},
    }

    fmt.Println("原始任务列表:", jobs)

    // 应用最短完成时间策略进行排序
    sortedJobs := MinCompletionTimes(jobs)
    fmt.Println("按最短完成时间排序后的任务列表:", sortedJobs)

    // 验证转换的等效性
    x := []Job{{"E", 1, 1}, {"F", 2, 2}}
    y := JobSlice(x) // []Job 到 JobSlice 的转换
    z := []Job(y)    // JobSlice 到 []Job 的转换

    fmt.Printf("\n原始切片 x: %v (类型: %T)\n", x, x)
    fmt.Printf("转换为 JobSlice 的切片 y: %v (类型: %T)\n", y, y)
    fmt.Printf("再转换为 []Job 的切片 z: %v (类型: %T)\n", z, z)

    // 检查底层数据是否相同
    if &x[0] == &y[0] && &y[0] == &z[0] {
        fmt.Println("x, y, z 的底层数据引用相同，说明转换是零开销的。")
    }
}

原始任务列表: [{A 10 5} {B 5 2} {C 8 8} {D 12 3}]
按最短完成时间排序后的任务列表: [{B 5 2} {D 12 3} {A 10 5} {C 8 8}]

原始切片 x: [{E 1 1} {F 2 2}] (类型: []main.Job)
转换为 JobSlice 的切片 y: [{E 1 1} {F 2 2}] (类型: main.JobSlice)
再转换为 []Job 的切片 z: [{E 1 1} {F 2 2}] (类型: []main.Job)
x, y, z 的底层数据引用相同，说明转换是零开销的。