map按key和按value排序

看一个题：
查找和排序
题目：输入任意（用户，成绩）序列，可以获得成绩从高到低或从低到高的排列,相同成绩
都按先录入排列在前的规则处理。
例示：
jack 70
peter 96
Tom 70
smith 67
从高到低 成绩
peter 96
jack 70
Tom 70
smith 67
从低到高
smith 67
Tom 70
jack 70
peter 96

1、按照value排序
2、可以递增排序和递减排序
3、保证排序的稳定性

golang map按key排序

1. //golang的map不保证有序性，所以按key排序需要取出key，对key排序，再遍历输出value
   
2. package main
   
3. 
   
4. import (
   
5.     "fmt"
   
6.     "sort"
   
7. )
   
8. 
   
9. func main() {
   
10.     // To create a map as input
    
11.     m := make(map[int]string)
    
12.     m[1] = "a"
    
13.     m[2] = "c"
    
14.     m[0] = "b"
    
15. 
    
16.     // To store the keys in slice in sorted order
    
17.     var keys []int
    
18.     for k := range m {
    
19.         keys = append(keys, k)
    
20.     }
    
21.     sort.Ints(keys)
    
22. 
    
23.     // To perform the opertion you want
    
24.     for _, k := range keys {
    
25.         fmt.Println("Key:", k, "Value:", m[k])
    
26.     }
    
27. }
    
28. 
    

复制代码

golang map按value排序

1. //要对golang map按照value进行排序，思路是直接不用map，用struct存放key和value，实现sort接口，就可以调用sort.Sort进行排序了。
   
2. // A data structure to hold a key/value pair.
   
3. type Pair struct {
   
4.     Key   string
   
5.     Value int
   
6. }
   
7. 
   
8. // A slice of Pairs that implements sort.Interface to sort by Value.
   
9. type PairList []Pair
   
10. 
    
11. func (p PairList) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
    
12. func (p PairList) Len() int           { return len(p) }
    
13. func (p PairList) Less(i, j int) bool { return p[i].Value < p[j].Value }
    
14. 
    
15. // A function to turn a map into a PairList, then sort and return it.
    
16. func sortMapByValue(m map[string]int) PairList {
    
17.     p := make(PairList, len(m))
    
18.     i := 0
    
19.     for k, v := range m {
    
20.         p[i] = Pair{k, v}
    
21.     }
    
22.     sort.Sort(p)
    
23.     return p
    
24. }

复制代码

golang map递增排序

1. //sort.Sort是递增排序，如果要实现递减排序，用sort.Reverse
   
2. package main
   
3. 
   
4. import (
   
5.     "fmt"
   
6.     "sort"
   
7. )
   
8. 
   
9. func main() {
   
10.     a := []int{4,3,2,1,5,9,8,7,6}
    
11.     sort.Sort(sort.Reverse(sort.IntSlice(a)))
    
12.     fmt.Println("After reversed: ", a)
    
13. }
    
14. 
    

复制代码

golang map 排序的稳定性

1. //sort不保证排序的稳定性（两个相同的值，排序之后相对位置不变），排序的稳定性由sort.Stable来保证。
   
2. package main
   
3. 
   
4. import (
   
5.     "fmt"
   
6.     "sort"
   
7. )
   
8. 
   
9. type person struct {
   
10.   Name string
    
11.   Age int
    
12. }
    
13. 
    
14. type personSlice []person
    
15. 
    
16. func (s personSlice) Len() int { return len(s) }
    
17. func (s personSlice) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
    
18. func (s personSlice) Less(i, j int) bool { return s[i].Age < s[j].Age }
    
19. 
    
20. func main() {
    
21.     a := personSlice {
    
22.       {
    
23.         Name: "AAA",
    
24.         Age: 55,
    
25.       },
    
26.       {
    
27.         Name: "BBB",
    
28.         Age: 22,
    
29.       },
    
30.       {
    
31.         Name: "CCC",
    
32.         Age: 0,
    
33.       },
    
34.       {
    
35.         Name: "DDD",
    
36.         Age: 22,
    
37.       },
    
38.       {
    
39.         Name: "EEE",
    
40.         Age: 11,
    
41.       },  
    
42.     }
    
43.     sort.Stable(a)
    
44.     fmt.Println(a)
    
45. }
    
46. 
    

复制代码

C++按value排序、递增和递减、排序的稳定性

1. /看一下本题的C++解法，C++ sort的第三个参数用来定义排序方法，即按key还是value排序，递增还是递减排序等，stable_sort用来保证排序的稳定性，主要思路与golang解法相似，都是用struct封装key和value来代替map。
   
2. #include <iostream>
   
3. #include <vector>
   
4. #include <algorithm>
   
5. #include <string>
   
6. using namespace std;
   
7. struct student{
   
8.   string name;
   
9.     int score;
   
10. };
    
11. bool cmp0(const student &a, const student &b){
    
12.     // 从高到低排序
    
13.     return a.score > b.score;
    
14. }
    
15. bool cmp1(const student &a, const student &b){
    
16.     // 从低到高排序
    
17.     return a.score < b.score;
    
18. }
    
19. int main(){
    
20.     //freopen("in.txt", "r", stdin);
    
21.     //freopen("out.txt", "w", stdout);
    
22.     int N, type;
    
23.     while(cin >> N >> type){
    
24.         vector<student> stud(N);
    
25.          
    
26.         for(int i = 0; i < N; i ++){
    
27.             cin >> stud[i].name >> stud[i].score;
    
28.         }
    
29.         if(type == 0)
    
30.             stable_sort(stud.begin(), stud.end(), cmp0);   //稳定排序
    
31.         else
    
32.             stable_sort(stud.begin(), stud.end(), cmp1);
    
33.          
    
34.         for(int i = 0; i < N; i ++){
    
35.             cout << stud[i].name << " " << stud[i].score << endl;
    
36.         }
    
37.     }
    
38.      
    
39.     return 0;
    
40. }