//思路：利用结构体来进行存储，排序规则自定义compare函数，调用sort即可。
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
using namespace std;
typedef struct Data
{
    int id;
    string name;
    int value;
};

bool compare0(Data d1,Data d2)//降序
{
    if(d1.value==d2.value)
        return d1.id<d2.id;
    return d1.value>d2.value;
}

bool compare1(Data d1,Data d2)//升序
{
    if(d1.value==d2.value)
        return d1.id<d2.id;
    return d1.value<d2.value;
}
int main()
{
    int n,flag;
    while(cin>>n>>flag)
    {
        vector<Data>dvec;
        int id=1;
        string name;
        int value;
        Data data;
        for(int i=0;i<n;++i)
        {
            cin>>name>>value;
            data.id=id++;
            data.value=value;
            data.name=name;
            dvec.push_back(data);
        }
        if(flag==0)
            sort(dvec.begin(),dvec.end(),compare0);
        else
            sort(dvec.begin(),dvec.end(),compare1);
        for(int i=0;i<n;++i)
            cout<<dvec[i].name<<" "<<dvec[i].value<<endl;
	}
    return 0;
}

import java.util.*;
public class Main{
    static class Student{
        private String name;
        private Integer res;
        public Student(String name,Integer res){
            this.name = name;
            this.res = res;
        }
        public String getName(){
            return this.name;
        }
        public Integer getRes(){
            return this.res;
        }
        public void out(){
            System.out.println(this.name+" "+this.res);
        }
    }
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        while(sc.hasNext()){
            int n = sc.nextInt();
            int flag = sc.nextInt();
            List<Student> list = new ArrayList<Student>();
            for(int i =0 ;i < n; i++){
                String name = sc.next();
                int res = sc.nextInt();
                list.add(new Student(name,res));
            }
            for(int i = 0; i< list.size()-1; i++ ){
                for(int j =0; j< list.size()-1-i; j++){
                    if( flag ==1?list.get(j).getRes()>list.get(j+1).getRes():
                       list.get(j).getRes()<list.get(j+1).getRes()){
                        Student tmp = list.get(j);
                        list.set(j,list.get(j+1));
                        list.set(j+1,tmp);
                    }
                }
            }
            for(Student s:list){
                s.out();
            }
        }
    }
}

#include<vector>
#include<string>
#include<iostream>
#include<algorithm>
using namespace std;

struct Student{
    string name;
    int score;
    int index;
};
int flag;

bool cmp(Student a, Student b){
    if(flag == 1 && a.score!=b.score) return a.score<b.score;
    else if(flag == 0 && a.score!=b.score) return a.score>b.score;
    return a.index< b.index;
}

int main(){
    int n;
    while(cin>>n){
        int score;
        string name;
        cin>>flag;
        vector<Student> stu;
        for(int i=0;i<n;i++){
            cin>>name>>score;
            stu.push_back({name,score,i});
        }
        sort(stu.begin(),stu.end(),cmp);
        for(int i=0;i<n;i++)
            cout<<stu[i].name<<' '<<stu[i].score<<endl;
    }
}

//使用Arrays的sort排序，重写比较方法
import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int n=sc.nextInt();
            int pattern=sc.nextInt();
            String[][] table=new String[n][2];
            for(int i=0;i<n;++i){
                table[i][0] = sc.next();
                table[i][1] = sc.next();
            }
            MyComparator1 myCom1=new MyComparator1();
            MyComparator2 myCom2=new MyComparator2();
            Arrays.sort(table,pattern==1?myCom1:myCom2);
            for(int i=0;i<n;++i){
                System.out.print(table[i][0]+" "+table[i][1]);
                System.out.println();
            }
        }
    }
}
class MyComparator1 implements Comparator<String[]>{
    public int compare(String[] s1, String[] s2){
        return Integer.parseInt(s1[1])-Integer.parseInt(s2[1]);
    }
}
class MyComparator2 implements Comparator<String[]>{
    public int compare(String[] s1, String[] s2){
        return Integer.parseInt(s2[1])-Integer.parseInt(s1[1]);
    }
}

import java.util.Scanner;
import java.util.Arrays;

/* 成绩排序，重写字符串排序比较器*/
public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);

        while (in.hasNextLine()) {
            int n = Integer.parseInt(in.nextLine());
            int order = Integer.parseInt(in.nextLine());

            String[] arr = new String[n];
            for (int i = 0; i < n; i++)
                arr[i] = in.nextLine();

            Arrays.sort(arr, (s1, s2) -> {
                int i1 = Integer.parseInt(s1.split(" ")[1]);
                int i2 = Integer.parseInt(s2.split(" ")[1]);
                return order == 0 ? i2 - i1 : i1 - i2;
            });

            for (String s : arr)
                System.out.println(s);
        }

        in.close();
    }
}

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()){
            int num = scanner.nextInt();
            int order = scanner.nextInt();
            List<Integer> grades = new ArrayList<>();
            List<String>[] names = new ArrayList[101];
            for (int i = 0; i < num; i++){
                String name = scanner.next();
                int grade = scanner.nextInt();
                grades.add(grade);
                if (names[grade] == null){
                    names[grade] = new ArrayList<>();
                }
                names[grade].add(name);
            }
            Collections.sort(grades, new Comparator<Integer>(){
                public int compare(Integer entry1, Integer entry2){
                    if (order == 0){
                        return entry2 - entry1;
                    }else{
                        return entry1 - entry2;
                    }
                }
            });
            for (Integer e : grades){
                System.out.println(names[e].get(0) + " " + String.valueOf(e));
                names[e].remove(0);
            }
        }
    }
}

Python 解法

if __name__ == "__main__":
    while True:
        try:
            n = int(input())
            t = int(input())
            data = [input().strip().split() for i in range(n)]
            data.sort(key=lambda x: int(x[1]),reverse = not t)#排序的关键字是int(x[1])，直接x[1]会报错
            for l in data:
                print(" ".join(l))
        except:
            break

代码：

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

class Student{
public:
    Student(){};
    Student(string s, int i):name(s),soc(i){}
    Student(const Student &st)
    {
        this->name = st.name;
        this->soc = st.soc;
    }
    
    static bool myup(const Student &s1, const Student &s2)
    {
        return s1.soc < s2.soc;
    }

    static bool mydown(const Student &s1, const Student &s2)
    {
        return s1.soc > s2.soc;
    }
    
    string name;
    int soc;
};


int main()
{
    int num, flag;
    while(cin >> num)
    {
        cin >> flag;
        vector<Student> arr(num);
        for(int i = 0; i < num; i++)
            cin >> arr[i].name >> arr[i].soc;
        
        if(flag)
            stable_sort(arr.begin(), arr.end(), Student::myup);
        else
            stable_sort(arr.begin(), arr.end(), Student::mydown);
        
        for(int i = 0; i < arr.size(); i++)
            cout << arr[i].name <<" "<< arr[i].soc << endl;
    }

    return 0;
}

#include <bits/stdc++.h>
using namespace std;
int main(){
    for(int n,p;cin>>n>>p;){
        vector<pair<string,int>> vec(n);
        for(auto &user:vec) cin>>user.first>>user.second;
        if(!p) stable_sort(vec.begin(),vec.end(),
                [](const pair<string,int>& p1, const pair<string,int>& p2){return p1.second > p2.second;});
        else stable_sort(vec.begin(),vec.end(),
               [](const pair<string,int>& p1, const pair<string,int>& p2){return p1.second < p2.second;});
        for(auto user:vec) cout << user.first << ' ' << user.second << endl;
    }
}

#include <iostream>
#include <map>
#include <vector>
#include <algorithm>

using namespace std;

void display(const pair<int, vector<string>>& p)
{
    const vector<string> & v = p.second;
    for (const auto &name : v) {
        cout <<  name << " " << p.first << endl;
    }
}

int main(void)
{
    int n;
    int flag;
    string name;
    int score;

    map<int, vector<string>> mapScore;
    while (cin >> n >> flag) {
        mapScore.clear();
        while (n--) {
            cin >> name >> score;
            mapScore[score].push_back(name);
        }
        if (flag == 0) { // 从大到小
            for_each(mapScore.rbegin(), mapScore.rend(), display);
        } else if (flag == 1) { //从小到大
            for_each(mapScore.begin(), mapScore.end(), display);
        }
    }
    return 0;
}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        while (sc.hasNext()) {
            int n=sc.nextInt();
            int b=sc.nextInt();
            LinkedHashMap<String,Integer> map = new LinkedHashMap<String,Integer>();
            for (int i = 0; i <n ; i++) {
                String name=sc.next();
                int score=sc.nextInt();
                map.put(name+" "+score,score);
            }
            //用键值对排序
            List<Map.Entry<String, Integer>> list = new ArrayList<>(map.entrySet());
            if(b==0){//降序
                Collections.sort(list, (o1,o2)->(o2.getValue()-o1.getValue()));
            }else if(b==1){//升序
                Collections.sort(list, (o1,o2)->(o1.getValue()-o2.getValue()));
            }
            for(Map.Entry<String, Integer> entry:list){
                System.out.println(entry.getKey());
            }
        }
        sc.close();
    }

}

#include<vector>
(721)#include<string>
#include<iostream>
(720)#include<stdlib.h>
#include<algorithm>
using namespace std;

typedef struct student
{
	string name;
	int score;
};

void  Grade_Sort(vector<student> &ans,int &sort_flag)
{
	//  执行成绩排序

	student temp;
	for (int i = 0; i < ans.size() - 1; i++)
	{
		for (int j = 0; j < ans.size() - 1; j++)
		{
			if (sort_flag)
			{
				if (ans[j].score > ans[j+1].score)
				{
					temp = ans[j];
					ans[j] = ans[j + 1];
					ans[j + 1] = temp;
				}
			}
			else
			{
				if (ans[j].score < ans[j + 1].score)
				{
					temp = ans[j];
					ans[j] = ans[j + 1];
					ans[j + 1] = temp;
				}
			}
		}
	}
}

int main()
{
	vector<student> ans;
	int num;
	student  stu;
	int sort_flag;
	while (cin >> num)
	{
		cin >> sort_flag;
		for (int i = 0; i < num; i++)
		{
			cin >> stu.name >> stu.score;
			ans.push_back(stu);
		}

		Grade_Sort(ans, sort_flag);

		//循环打印
		for (auto it = ans.begin(); it != ans.end(); it++)
		{
			cout << it->name << ' ' << it->score << endl;
		}
		// 清空容器
		ans.clear();
	}
	system("pause");
	return 0;
}

用map和map<greater>分别装一下就行了，让他自己排序</greater>

#include<iostream>
(720)#include<map>

using namespace std;

int main() {
    int num;
    while(cin >> num) {
        int mod;
        cin >> mod;
        if(mod == 0) {
            string name;
            int scor;
            multimap<int, string, greater<int>> ismap;
            while(num--) {
                cin >> name >> scor;
                ismap.insert(pair<int, string>(scor, name));
            }
            for(auto m : ismap) {
                cout << m.second << ' ' << m.first << endl;
            }
        }
        else {
            string name;
            int scor;
            multimap<int, string> ismap;
            while(num--) {
                cin >> name >> scor;
                ismap.insert(pair<int, string>(scor, name));
            }
            for(auto m : ismap) {
                cout << m.second << ' ' << m.first << endl;
            }
        }
    }

    return 0;
}

虽然说是一种很笨的办法（因为框架集合不熟练），但是觉得应该会对有需要的人有帮助
思路还是将名字+成绩放在第一个数组，成绩放在第二个数组，按成绩大小来输出第一个数组

import java.util.*;
public class Main{
  public static void main(String[] args){
    Scanner key =new Scanner(System.in);
    while(key.hasNext()){
      int num = key.nextInt();
      int way = key.nextInt();
      String[] array = new String[num];
      int[] array1 =new int[num];
      for(int i=0;i<num;i++){
        String temp = key.next();
        int temp1 = key.nextInt();
        String temp2 = temp+" "+temp1;
        array[i]=temp2;
        array1[i]=temp1;
      }
      if(way==0){
        for(int j=0;j<num;j++){
        int max = array1[num-1];
        int we = num-1;
        for(int i=num-1;i>=0;i--){
          if(array1[i]>=max){
            max = array1[i];
            we=i;
          }
        }
          System.out.println(array[we]);
          array1[we]=-1;
      }
      }
      if(way==1){
        for(int j=0;j<num;j++){
          int min = array1[num-1];
          int we = num-1;
          for(int i=num-1;i>=0;i--){
            if(array1[i]<=min){
              min = array1[i];
              we = i;
            }
          }
          System.out.println(array[we]);
          array1[we]=100000;
        }
      }
    }
  }
}

	#include<iostream>
#include<string>
#include<map>
#include<algorithm>



	using namespace std;



	int main()
{
    int m,f;
    while(cin>>m)
    {
        cin>>f;
        multimap<int,string> map;
        multimap<int,string,greater<int>> min;
        string str;
        int num;
        for(int i=0;i<m;i++)
        {
            cin>>str>>num;
            map.insert(pair<int,string>(num,str));
            min.insert(pair<int,string>(num,str));
        }
        if(f==0)
        {
            for(multimap<int,string,greater<int>>::iterator it=min.begin();it!=min.end();it++)
            {
                cout<<it->second<<' '<<it->first<<endl;
            }
        }
        else 
        {
            for(multimap<int,string>::iterator it=map.begin();it!=map.end();it++)
            {
                cout<<it->second<<' '<<it->first<<endl;
            }
        }
    }
    return 0;
}