go语言中常用的功能之七（二维数组按某列排序）

待我称王封你为后i 2022-03-19 15:08 313阅读 0赞

> 本文讲解切片（数组）的排序，为什么是切片，而不是数组，因为数组是定长的，且不能改变长度，而切片是可扩展长度的，而且切片的传值排序会直接改变其本身的顺序

### 文章目录 ###

*   *   *  1. 普通排序
         *   *  1.1 数字切片排序
             *  1.2 其他类型切片排序
         *  2. 自定义实现排序
         *  3.二维数组按某列排序

### 1. 普通排序 ###

#### 1.1 数字切片排序 ####

a := []int{ 4,5,7,3,2}
    sort.Ints(a)
    fmt.Println(a)

打印结果：  
\[2 3 4 5 7\]

#### 1.2 其他类型切片排序 ####

<table> 
 <thead> 
  <tr> 
   <th>类型</th> 
   <th>函数</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int</td> 
   <td>sort.Ints(a []int)</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>sort.Float64s(a []float64)</td> 
  </tr> 
  <tr> 
   <td>int</td> 
   <td>sort.Strings(a []string)</td> 
  </tr> 
 </tbody> 
</table>

### 2. 自定义实现排序 ###

> go提供了一个`sort`包，只要每个结构体实现了下面三个方法，既可以直接调用`Sort`方法

func (a Type)Len() int { }
    func (a Type)Less(i,j int) bool { }
    func (a Type)Swap(i,j int){ }

举个栗子：

type Sd struct { 
    	Id int
    	Score float64
    }
    type Ssd []Sd
    
    
    func (sd Ssd)Len() int { 
    	return len(sd)
    }
    func (sd Ssd)Less(i,j int) bool { 
    	return sd[i].Id < sd[j].Id
    }
    
    func (sd Ssd)Swap(i,j int){ 
    	sd[i],sd[j] = sd[j],sd[i]
    }
    
    func main(){ 
       sd := Ssd{ 
    		{ 2,12.3},
    		{ 1,17.3},
    		{ 4,15.3},
    		{ 3,13.3},
    	}
    	sort.Sort(sd)
    	fmt.Println(sd)
    }

打印结果：  
\[\{1 17.3\} \{2 12.3\} \{3 13.3\} \{4 15.3\}\]

### 3.二维数组按某列排序 ###

> 按照切片的操作，上面的三个方法，其实有两个方法是不管什么样的结构体都是一样的，所以sort包又给我们提供了一个通用的方法`sort.Slice`

type Data struct { 
    	Id int
    	Name string
    	Score float32
    	Age int
    	High float32
    }
    
    func sortByColumn(column string,data []Data) { 
    
    	sort.Slice(data, func(i, j int) bool { 
    		switch column { 
    		case "Id":
    			return data[i].Id < data[j].Id
    		case "Name":
    			return data[i].Name < data[j].Name
    		case "Score":
    			return data[i].Score < data[j].Score
    		case "Age":
    			return data[i].Age < data[j].Age
    		case "High":
    			return data[i].High < data[j].High
    		default:
    			return data[i].Id < data[j].Id
    		}
    
    	})
    }
    func main() { 
        var data = []Data{ 
    		{ 5,"zhangsan",92,20,1.75},
    		{ 3,"lisi",100,22,1.85},
    		{ 2,"wangwu",67,19,1.65},
    		{ 4,"zhaoliu",88,21,1.71},
    		{ 1,"wuqi",90,20,1.70},
    	}
    	sortByColumn("Score",data[:])
    	for _,v := range data { 
    		fmt.Println(v)
    	}
    }

打印结果：  
\{2 wangwu 67 19 1.65\}  
\{4 zhaoliu 88 21 1.71\}  
\{1 wuqi 90 20 1.7\}  
\{5 zhangsan 92 20 1.75\}  
\{3 lisi 100 22 1.85\}

如果有更好的方案，欢迎评论