用反射实现二维数组key-value排序

首先了解一下概念：

反射是用来检测存储在接口变量内部(值value，类型type) 的一种机制。在Golang的reflect反射包中，提供了两种类型（或者说两个方法）让我们可以很容易的访问接口变量内容，分别是reflect.ValueOf() 和 reflect.TypeOf()：

reflect.TypeOf： 直接给我们想要的type类型，如float64、int、指针、struct 等类型 reflect.ValueOf：直接给我们想要的具体的值，如520具体数值，或者类似&{13 "Hy" 26} 结构体struct的值

具体用法清参考reflect包文档。

快速排序 O(nlog2 n) 最坏O(n^2) 基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

import (
    "fmt"
    "reflect"
)

type info struct {
    name      string
    sex        int
    createTime int
}

type User struct {
    userID    int
    playerTime int
    playerInfo info
}

func main() {
    users := []User{
        {
            userID:    10,
            playerTime: 1539158076,
            playerInfo: info{
                name:      "小明10",
                sex:        1,
                createTime: 1539158000,
            },
        },
        {
            userID:    20,
            playerTime: 1539150000,
            playerInfo: info{
                name:      "小明15",
                sex:        1,
                createTime: 1539150000,
            },
        },
        {
            userID:    30,
            playerTime: 1539150000,
            playerInfo: info{
                name:      "小明15",
                sex:        1,
                createTime: 1539150000,
            },
        },
        {
            userID:    19,
            playerTime: 1539150000,
            playerInfo: info{
                name:      "小明15",
                sex:        1,
                createTime: 1539150000,
            },
        },
        {
            userID:    13,
            playerTime: 1539150000,
            playerInfo: info{
                name:      "小明15",
                sex:        1,
                createTime: 1539150000,
            },
        },
        {
            userID:    3,
            playerTime: 1539150000,
            playerInfo: info{
                name:      "小明15",
                sex:        1,
                createTime: 1539150000,
            },
        },
        },
    }
    sortList(users)
    fmt.Println(users)
}
func sortList(values []User) {
    quickSort(values, 0, len(values)-1, "userID")
}

//根据二维key值 int型排序  升序 快排
func quickSort(values []User, left int, right int, sortName string) {
    user := reflect.ValueOf(values[left]) //取出第一项
    leftUser := values[left]
    key := user.FieldByName(sortName).Int()
    p := left
    i, j := left, right
    for i <= j {
        //由后开始向前搜索(j--)，找到第一个小于key的值values[j]
        for j >= p && reflect.ValueOf(values[j]).FieldByName(sortName).Int() >= key {
            j--
        }
        //第一个小于key的值 赋给 values[p]
        if j >= p {
            values[p] = values[j]
            p = j
        }
        if reflect.ValueOf(values[i]).FieldByName(sortName).Int() <= key && i <= p {
            i++
        }
        if i < p {
            values[p] = values[i]
            p = i
        }
        values[p] = leftUser
        if p-left > 1 {
            quickSort(values, left, p-1, sortName)
        }
        if right-p > 1 {

            quickSort(values, p+1, right, sortName)

        }

    }

}