## 方法1
使用"sort"包下的Sort方法
```
func Sort(data Interface) {
n := data.Len()
quickSort(data, 0, n, maxDepth(n))
}
```
Sort接收Interface类型参数
```
type Interface interface {
// Len is the number of elements in the collection.
Len() int
// Less reports whether the element with
// index i should sort before the element with index j.
Less(i, j int) bool
// Swap swaps the elements with indexes i and j.
Swap(i, j int)
}
```
Interface是一个接口类型，所以想对二维切片排序必须重写Len、Less、Swap三个方法
切片没有这三个方法，但是我们可以定义新类型，给新类型添加方法，如下
```
type sortable [][]int
func (s sortable) Len() int {
return len(s)
}
func (s sortable) Less(i,j int) bool {
if s[i][0]==s[j][0] {
return s[i][1]<=s[j][1]
}
return s[i][0]<=s[j][0]
}
func (s sortable) Swap(i,j int) {
s[i],s[j]=s[j],s[i]
}
```
排序时使用sortable对int[][]做类型转换
```
slice:=[][]int{
{4,2},
{3,5},
{3,1},
}
sort.Sort(sortable(slice))
```
## 方法2
使用"sort"包下的Slice方法
```
func Slice(slice interface{}, less func(i, j int) bool) {
rv := reflectValueOf(slice)
swap := reflectSwapper(slice)
length := rv.Len()
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
}
```
Slice接受任意类型和一个func（等价于java中的比较器）
所以对二维切片排序只需要写less方法
```
slice:=[][]int{
{4,2},
{3,5},
{3,1},
}
var less func(i,j int) bool
less=func(i,j int) bool {
if slice[i][0]==slice[j][0] {
return slice[i][1]<=slice[j][1]
}
return slice[i][0]<=slice[j][0]
}
sort.Slice(slice,less)
```
有疑问加站长微信联系（非本文作者））
