精华内容
下载资源
问答
  • sort自定义排序

    千次阅读 2018-03-17 11:08:13
    1.SORT介绍 用于C++中,对给定区间所有元素进行排序。 使用的排序方法类似于快排的方法,时间复杂度为n * log2(n),执行效率较高 头文件#include< algorithm> 2.sort使用方法 sort...

    1.SORT介绍
    用于C++中,对给定区间所有元素进行排序。
    使用的排序方法类似于快排的方法,时间复杂度为n * log2(n),执行效率较高
    头文件#include< algorithm>
    2.sort使用方法
    sort函数有3个参数,sort(first, last,cmp)
    其中,first是元素的起始地址,last是结束地址,cmp是排序的方式。对(first,last)区间内数据根据cmp的方式进行排序。也可以不写第三个参数,此时按默认排序,从小到大进行排序。
    3.

    //方案1:自定义比较函数cmp
    #include<iostream>
    #include<algorithm>
    using namespace std;
    //当b<a时,认为a小于b,所以排序的结果就是将元素按从大到小的顺序排序
    bool cmp(int a,int b)
    {
        return b < a;
    }
    int main()
    {
        int a[5] = {1,5,2,4,3};
        sort(a,a + 5,cmp);
        for(int i = 0 ; i < 5 ; i++)
            cout << a[i] << endl;
    }
    
    //方案2:重载比较运算符“<”
    //和方案一同理,如果认为第一个参数比第二个小就返回true,反之返回false
    bool operator<(const Student& s1,const Student& s2)
    
    {
        if(s1.age == s2.age)
            return s1.name < s2.name;//年龄相同时,按姓名小到大排
        else return s1.age > s2.age;//从年龄大到小排序
    }
    sort(a,a + n);
    
    //方案3:声明比较类
    //与前两种方案同理
    struct cmp
    {
    bool operator()(const Student& s1,const Student& s2)
        {
            if(s1.age == s2.age)
                return s1.name < s2.name;//年龄相同时,按姓名小到大排
            else return s1.age > s2.age;//从年龄大到小排序
        }
    };
    sort(a,a + n,cmp());
    
    

    例题:

    /*题目1:
     读入n条学生成绩记录,包括学生姓名和总成绩,要求按成绩从高到低输出n条记录,每条记录占一行。(成绩不会重复)
     
     输入:
     第一行读入一个 n ( 0<n<=100)  接下来n行每行读入学生姓名和成绩,中间以空格隔开
     
     输出:
     n行按成绩排序的记录。
     
     样例输入
     3
     ywz 94
     lsx 85
     wjx 100
     样例输出
     wjx 100
     ywz 94
     lsx 85*/
    
    #include<iostream>
    #include<algorithm>
    using namespace std;
    class Student
    {
    public:
        string name;
        int grade;
        
    };
    bool operator<(const Student& s1,const Student& s2)
    
    {
        if(s1.grade == s2.grade)
            return s1.name < s2.name;//年龄相同时,按姓名小到大排
        else return s1.grade > s2.grade;//从年龄大到小排序
    }
    
    int main()
    {
        int n;
        cin >> n;
        Student s[n];
        for(int i = 0 ; i < n ; i++)
            cin >> s[i].name >> s[i].grade;
        sort(s,s + n);
        for(int i = 0; i < n ; i++)
            cout << s[i].name << " " << s[i].grade << endl;
    }
    
    
    /*题目2: 
    读入n条学生成绩记录,包括学生姓名,总成绩,语文,数学和英语成绩,要求按总成绩从高到低输出n条记录,每条记录占一行。总成绩相同时按语文成绩从高到低输出,语文成绩相同时按数学成绩从高到低输出。(没有两个人的成绩完全一样)
     
     输入:
     第一行读入一个 n ( 0<n<=100)  接下来n行每行读入学生姓名,总成绩,语文,数学和英语成绩,中间以空格隔开
     
     输出:
     n行按要求排序好的记录。
     
     样例输入
     3
     Lsx 270 90 90 90
     Ywz 275 92 93 90
     Wjx 255 85 85 85
     样例输出
     Ywz 275 92 93 90
     Lsx 270 90 90 90
     Wjx 255 85 85 85*/
    
    
    #include<iostream>
    #include<algorithm>
    using namespace std;
    class Student
    {
    public:
        string name;
        int grade;
        int chinese,math,english;
        
    };
    bool operator<(const Student& s1,const Student& s2)
    
    {
        if(s1.grade != s2.grade)return s1.grade > s2.grade;//如果不相等
        else//如果总成绩相同
        {
            if(s1.chinese != s2.chinese)
            return s1.chinese > s2.chinese;//总成绩相同时,按语文成绩高的排。
           
            
            if(s1.math != s2.math)
                return s1.math > s2.math;//语文也相同时,按数学成绩高的排。
            
             return s1.english > s2.english;
        }
    }
    
    int main()
    {
        int n;
        cin >> n;
        Student s[n];
        for(int i = 0 ; i < n ; i++)
            cin >> s[i].name >> s[i].grade >> s[i].chinese >> s[i].math >>  s[i].english;
        sort(s,s + n);
        for(int i = 0; i < n ; i++)
            cout << s[i].name << " " << s[i].grade << " " << s[i].chinese << " " << s[i].math << " " << s[i].english << endl;
    }
    
    /*题目3:
    题目描述:
     小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是,这些日期采用的格式非常不统一,有采用年/月/日的,有采用月/日/年的,还有采用日/月/年的。更加麻烦的是,年份也都省略了前两位,使得文献上的一个日期,存在很多可能的日期与其对应。
     
     比如02/03/04,可能是2002年03月04日、2004年02月03日或2004年03月02日。
     
     给出一个文献上的日期,你能帮助小明判断有哪些可能的日期对其对应吗?
     
     输入:
     一个日期,格式是”AA/BB/CC”。 (0 <= A, B, C <= 9)
     
     输出:
     输出若干个不相同的日期,每个日期一行,格式是”yyyy-MM-dd”。多个日期按从早到晚排列。
     
     样例输入
     02/03/04
     样例输出
     2002-03-04
     2004-02-03
     2004-03-02*/
    
    
    #include <iostream>
    #include <cstring>
    #include <string>
    #include <set>
    #include <iterator>
    #include <algorithm>
    using namespace std;
    
    int md[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    
    void insert(int y, int m, int d);
    
    struct Date
    {
        int year,
        month,
        day;
        
        Date(int y, int m, int d)
        {
            year = y; month = m; day = d;
        }
        
        bool operator < (Date b) const
        {
            if (year == b.year)
            {
                if (month == b.month)
                    return day < b.day;
                return month < b.month;
            }
            return year < b.year;
        }
        
        bool isOK()//判断日期是否合法
        {
            if (year < 1960 || year > 2059) return false;
            if (month <= 0 || month > 12) return false;
            if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0))
            {
                if (month == 2)  //闰年
                    return day >= 1 && day <= 29;
                return day >= 1 && day <= md[month];
            }
            else
                return day >= 1 && day <= md[month];
        }
        
        void printDate() const
        {
            printf("%d-%02d-%02d\n", year, month, day); // %02d: 不足二位则补0
        }
        
    };
    
    set<Date> ss;
    
    void insert(int y, int m, int d)
    {
        Date t(y, m, d);
        if (t.isOK()) {
            ss.insert(t);
        }
    }
    
    int main()
    {
        int a, b, c;
        scanf("%d/%d/%d", &a, &b, &c);  //输入格式是 xx/xx/xx
        
            //年月日
        insert(1900+a, b, c);
        insert(2000+a, b, c);
        
            //月日年
        insert(1900+c, a, b);
        insert(2000+c, a, b);
        
            //日月年
        insert(1900+c, b, a);
        insert(2000+c, b, a);
        
        set<Date>::iterator it = ss.begin();
        
        for (; it != ss.end(); ++it)
            it->printDate();
        
        return 0;
    }
    
    
    展开全文
  • Sort自定义排序

    2016-08-02 11:53:21
    有的时候,我们需要对list这种格式的数据根据Model中的某一属性进行排序,怎么办呢?首先需要实现Comparator接口 class DataModelComparator implements Comparator { @Override public int compare(DataModel ...

    有的时候,我们需要对list<Model>这种格式的数据根据Model中的某一属性进行排序,怎么办呢?首先需要实现Comparator接口

    class DataModelComparator implements Comparator<DataModel> {
    
            @Override
            public int compare(DataModel dataModel, DataModel t1) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm");
                try {
                    if(sdf.parse(dataModel.getModitime()).after(sdf.parse(t1.getModitime()))){
                        return -1;
                    }else{
                        return 1;
                    }
                } catch (ParseException e) {
                    e.printStackTrace();
    
                }
                return 0;
            }
        }

    判断return的值,-1第一个参数在第二个参数上方,1第一个参数在第二个参数下方。

    然后调用

    Collections.sort(list, new DataModelComparator());
    就可以了。
    展开全文
  • C++中的sort自定义排序函数

    万次阅读 多人点赞 2019-01-24 09:14:31
    C++中sort自定义排序 1.sort简介: (1)用于C++中,对给定区间所有元素进行排序; (2)使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n),执行效率较高; (3)头文件 #include &lt;algo...

                                                                                   C++中sort自定义排序

    1.sort简介:

    (1)用于C++中,对给定区间所有元素进行排序;

    (2)使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n),执行效率较高;

    (3)头文件 #include <algorithm>。

     

    2.sort使用方法

    sort函数有三个参数

    sort(first,last,cmp);

    其中,first是元素的起始地址last结束地址cmp排序的方式。对[first,last)(一定要注意这里的区间是左闭又开)区间内数据根据cmp的方式进行排序。也可以不写第三个参数,此时按默认排序,从小到大进行排序。

     

     

    3.自定义排序

    (1)自定义比较函数cmp

    比如:

    bool  cmp(int a,int b)

    {

            return b<a;

    }

    sort(a,a+n,cmp);

    传入的参数类型和需要排序的数据类型一致,如果认为第一个参数比第二个小,也就是第一个参数需要排在第二个参数前面时返回true,反之返回 false。系统默认a<b时返回true,于是从小到大排。而上面的例子是当b小于a时,认为a小于b。所以排序的结果就是将元素按从大到小的顺序排序。

     

    (2)重载比较运算符“<”

    如:

    bool operator< (const Student& s1, const Student& s2)

    {

            if(s1.age==s2.age)

                    return s1.name <s2.name;//年龄相同时,按姓名小到大排

            else  return s1.age > s2.age; //从年龄大到小排序

    }

    sort(a,a+n);

    这里一定要注意一下:

    参数类型如果是自定义类型,比如自己定义的结构体,类,尽管sort函数默认是从小到大排列,但是这里必须要重载比较运算符“<”!!!

    和cmp函数同理,如果认为第一个参数比第二个小就返回true,反之返回 false。

     

    (3)声明比较类

    struct cmp

    {

           bool operator() (const Student& s1, const Student& s2)

           {

                  if(s1.age==s2.age)

                         return s1.name <s2.name;

                  else  return s1.age < s2.age;

            }

    };

    sort(a,a+n,cmp());

    还是同理,如果认为第一个参数比第二个小就返回true,反之返回 false。

     

    (4) functional提供了一堆基于模板的比较函数对象:equal_to<Type>、not_equal_to<Type>、greater<Type>、greater_equal<Type>、less<Type>、less_equal<Type>。对于这个问题来说,greater和less就足够了,直接拿过来用:

    升序:sort(begin,end,less<data-type>());

    降序:sort(begin,end,greater<data-type>()。

     

     

    【第八届蓝桥杯】日期问题

          小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是,这些日期采用的格式非常不统一,有采用年/月/日的,有采用月/日/年的,还有采用日/月/年的。更加麻烦的是,年份也都省略了前两位,使得文献上的一个日期,存在很多可能的日期与其对应。 比如02/03/04,可能是2002年03月04日、2004年02月03日或2004年03月02日。 给出一个文献上的日期,你能帮助小明判断有哪些可能的日期对其对应吗?

    输入:

    一个日期,格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)

    输出:

    输出若干个不相同的日期,每个日期一行,格式是"yyyy-MM-dd"。多个日期按从早到晚排列。

    样例输入:

    02/03/04

    样例输出:

    2002-03-04

    2004-02-03

    2004-03-02

    思路:自定义date结构体,

    对输入的三个数字按年月日月日年日月年的排序分别判断其合理性,若合理则存入数组中,最后排序去重后按要求输出。

    #include <iostream>
    #include <algorithm>
    using namespace std;
    
    class date
    {
    public:
    	int year;
    	int month;
    	int day;
    };
    
    date x[100];
    
    bool operator<(const date& a, const date& b)
    {
    	//重载<符号来比较日期的大小
    	if (b.year == a.year)
    	{
    		if (b.month == a.month)
    		{
    			return a.day < b.day;
    		}
    		else
    		{
    			return a.month < b.month;
    		}
    	}
    	else
    	{
    		return a.year < b.year;
    	}
    }
    
    int md[13] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    
    bool judge(date a)
    {
    	if (a.year < 1960 || a.year>2059)
    		return false;
    	if (a.month <= 0 || a.month > 12)
    		return false;
    	if (a.year % 400 == 0 || (a.year % 100 != 0 && a.year % 4 == 0))
    	{
    		//闰年
    		if (a.month == 2)
    		{
    			return a.day >= 1 && a.day <= 29;
    		}
    		return a.day >= 1 && a.day <= md[a.month];
    	}
    	else
    		return a.day >= 1 && a.day <= md[a.month];
    }
    
    int cnt = 0;
    
    void myscanf(int a, int b, int c)
    {
    	//如果日期合法则插入数组中
    	date d;
    	d.year = a;
    	d.month = b;
    	d.day = c;
    	if (judge(d))
    	{
    		x[cnt++] = d;
    	}
    }
    
    int main()
    {
    	int a, b, c;
    	scanf_s("%d/%d/%d", &a, &b, &c);
    	//年月日
    	myscanf(1900 + a, b, c);
    	myscanf(2000 + a, b, c);
    	//月日年
    	myscanf(1900 + c, a, b);
    	myscanf(2000 + c, a, b);
    	//日月年
    	myscanf(1900 + c, b, a);
    	myscanf(2000 + c, b, a);
    	sort(x, x + cnt);
    	for (int i = 0; i < cnt; ++i)
    	{
    		//去重
    	        if (x[i].year != x[i - 1].year || x[i].month != x[i - 1].month || x[i].day != x[i - 1].day)
    			printf("%d-%02d-%02d\n", x[i].year, x[i].month, x[i].day);
    	}
    	system("pause");
    	return 0;
    
    }

     

    展开全文
  • C++ sort自定义排序的3种方式 sort默认降序,以自定义升序排列为列 方法1 谓词 bool compare(int m, int n) { return m>n; } int main() { vector<int>nums = { 10,2,51 }; sort(nums.begin(), nums....

    C++ sort自定义排序的3种方式

    sort默认降序,以自定义升序排列为列

    方法1 谓词

    bool compare(int m, int n)
    {
    	return m>n;
    
    }
    int main()
    {
    	vector<int>nums = { 10,2,51 };
    	sort(nums.begin(), nums.end(), compare);
    	system("pause");
    }
    

    方法2 重载小括号()

    class compare
    {
    	bool operator()(int m, int n)
    	{
    		return m>n;
    
    	}
    };
    
    int main()
    {
    	vector<int>nums = { 10,2,51 };
    	sort(nums.begin(), nums.end(), compare());
    	system("pause");
    }
    

    方法3 Lambda表达式(匿名函数)

    int main()
    {
    	vector<int>nums = { 10,2,51 };
    	sort(nums.begin(), nums.end(), [](int& a, int& b) {return a > b; });
    	system("pause");
    }
    

    附上lambda讲解

    链接: link.https://blog.csdn.net/bajianxiaofendui/article/details/86583612?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161829950516780265455373%2522%252C%2522scm%2522%253A%252220140713.130102334…%2522%257D&request_id=161829950516780265455373&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2allsobaiduend~default-1-86583612.pc_search_result_before_js&utm_term=c%2B%2B%E4%BB%BF%E5%87%BD%E6%95%B0

    展开全文
  • sort自定义排序注意

    2020-03-01 02:26:16
    https://blog.csdn.net/weixin_33766168/article/details/93787201 sort自定义函数时要注意不能恒为true,为runtimeerror
  • C++ algorithm sort自定义排序

    万次阅读 2017-08-03 11:41:07
    sort(a,a+n)代表从a首地址到a的尾地址按默认的从小到大排序 自定义 1)简单变量 bool compare(类型名称 a,类型名称 b){return a>b;} 按从大到小排序 sort(v.begin(),v.end(),compare); 2)简单结构体 struct stu ...
  • sort对于内置类型类型是升序排序,若要进行自定义排序有四种方法实现: - STL里的仿函数类。std::greater和std::less,他们在头文件\里,能对内置类型进行排序 - 自定义排序函数 - 仿函数类 - 重载operator<函数
  • sort函数对系统类型默认升序排列,当我们想降序排列或者对自定义数据类型排序时需要手写排序函数cmp,具体语句为sort(a.begin(),a.end(),cmp)。 在做leetcode501题目时,发现自定义sort排序函数报错:error: ...
  • Collections.sort自定义排序的使用方法 总结:Collections可以对List进行排序;如果想对Map进行排序,可以将Map转化成List,进行排序;   public static void hashMapSortTest() {...
  • c++ sort自定义排序

    2019-09-18 09:23:41
    sort(ins.begin(), ins.end(), [](Interval a, Interval b){return a.start ;}); res.push_back(ins[0]); for (int i = 1; i (); i++) { if (res.back().end [i].start) res.push_back(ins[i]); else res....
  • sort 自定义排序使用方法

    千次阅读 2018-07-14 14:18:07
    sort()排序函数是c++头文件include &lt;algorithm&gt;中的函数,它采用的是一种类似于快排的排序方式,时间复杂度 n*log2(n)。可以对 浮点数,整数,字符,字符串,结构体进行排顺序,排序方法不限于从大到...
  • Collections.sort(totalCheckList, new Comparator() { // 重写排序规则 匿名内部类实现 @Override public int compare(InstCheck check1, InstCheck check2) {
  • 【C++】sort自定义排序规则

    千次阅读 2019-07-03 14:51:28
    第三个参数compare,是个自定义的比较函数的指针,名字可以随便命名;原型如下: bool cmp (const Type1 &a,const Type2 & b ); 简单说来就是: 比较a和b,如果是想升序,那么就定义当a<b的时候返回true; ...
  • Lua Sort 自定义排序的注意事项

    千次阅读 2018-06-20 16:42:55
    要求传入两个相同的数时要返回false, 换句话说,下面的函数用&lt;=做比较,是错误的。...= v2 -- error end 测试local t = {4,3,2,1}table.sort(t,compare_func)for k, v in ipairs(t) do prin...
  • 这里有两种解决方案,一是重载list.sort()的操作运算符,二是通过list.sort(greater) 指定类似与回调函数的方式来排序。 [cpp] view plaincopyprint? // test.cpp :
  • 是你要进行排序的 数据结构或者说对象 所对应的类需要实现的接口,缺点是只能按你实现的这一种方式排序: public class UserInfo implements Comparable<UserInfo> { private int id; private String ...
  • Collection.sort自定义排序的使用方法

    千次阅读 2015-04-08 17:18:54
    Collection.sort默认是升序排序,要降序排序的话需修改sort的第二个参数Comparator中的函数,用第二个参数和第一个参数进行比较。 实例如下: public static void main(String[] args){ MapString,Str
  • Python3 sort 自定义比较逻辑:lambda函数、可比较类、cmp_to_key默认排序方式lambda函数自定义可比较类通过cmp_to_key自定义比较逻辑 以字符串排序为例,现在我们有这样一个字符串的 list : words = ["vanilla", ...
  • 7-37 模拟EXCEL排序(25 分)Excel可以对一组纪录按任意指定列排序。现请编写程序实现类似功能。输入格式:输入的第一行包含两个正整数N(≤10​5​​) 和C,其中N是纪录的条数,C是指定排序的列号。之后有 N行,每...
  • 这个解法很精妙,其中用到了sort自定义排序与lamda,借此回顾一下 进入正题 1.sort自定义排序 sort()排序函数是c++头文件include 中的函数,它采用的是一种类似于快排的排序方式,时间复杂度 n*log2(n)。...
  • sort函数自定义排序

    千次阅读 2020-12-15 18:09:29
    sort函数自定义排序 咳咳,自定义排序说实话用的地方还是很多的,像ACM里面,天梯赛里面,特别是天梯,必出这玩意。。。咳咳,水点字数,咱继续。 首先哈,我们来看一下c++自带的排序; 可以看出哈,默认是按...
  • 1.sort自定义排序返回true的理解 sort(first,last,cmp) bool cmp(const int& a,cosnt int& b) { return a<b; 1 //return b<a; 2 } 可以把参数中的a,b理解为从数组中顺序提取的两个数。这两个数的...
  • C++中优先队列和sort自定义排序算法对比!! 欢迎使用Markdown编辑器 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本...
  • C++ sort函数自定义排序规则

    万次阅读 2019-03-10 18:50:20
    没有自定义排序规则使用sort函数的额第三个参数,下面对sort总一个简单总结。 头文件:#include &lt;algorithm&gt; 第三个参数compare,是个自定义的比较函数的指针,名字可以随便命名;原型如下: bool...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 118,848
精华内容 47,539
关键字:

sort自定义排序