精华内容
下载资源
问答
  • sort自定义排序
    千次阅读
    2018-03-17 11:08:13

    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自定义排序方式

    2022-05-14 17:44:17
    当元素为结构体/pair等类型时,以及需要从大到小排序时,需要自定义。 方式1:结构体内重载运算符 对于结构体: 结构体按照某成员值,从小到大排序: 需要在结构体内重载运算符,从小到大重载<

    sort()

    sort(a.begin(), a.end());
    sort(a, a + n); // n为数组长度
    通常用于数组排序,排序方式为按照元素大小从小到大排序

    当元素为结构体/pair等类型时,以及需要从大到小排序时,需要自定义。

    方式1:结构体内重载运算符

    对于结构体
    结构体按照某成员值,从小到大排序:
    需要在结构体内重载运算符,从小到大重载<

    // 按照val从小到大排序
    struct Pair{
            int val, loc;
            // 结构体内重载运算符
            bool operator< (const Pair& t) const {
            	return val < t.val;
            }
        };
    // pp为Pair类型的vector数组
    sort(pp.begin(), pp.end()); // 按照val从小到大排序
    
    

    结构体按照某成员值,从大到小排序:
    需要在结构体内重载运算符,从大到小重载>

    // 按照val从大到小排序
    struct Pair{
            int val, loc;
            bool operator> (const Pair& t) const {
            	return val > t.val;
            }
        };
    // pp为Pair类型的vector数组
    sort(pp.begin(), pp.end(), greater<Pair>()); // 按照val从大到小排序
    

    方式2:cmp参数

    结构体

    // cmp参数
    struct Pair{
        int val, loc;
    };
    bool cmp(Pair num1, Pair num2){ // 可能需要static (leetcode)
        return num1.val < num2.val;
    }
    sort(pp.begin(), pp.end(), cmp);// 数组或vector都可,cmp如上为从小到大排序;改为>即可从大到小排序
    

    pair本质为结构体,同样也可

    typedef pair<int, int> PII;
    
    static bool cmp(PII num1, PII num2){
        return num1.first < num2.first; // < 从小到大排序
    }
    
    vector<PII> pp;
    sort(pp.begin(), pp.end(), cmp);
    

    与优先队列类比

    1. 一般的int数组:
    priority_queue<int> a; // 大根堆 
    priority_queue<int, vector<int>, greater<int>> b; // 小根堆
    
    1. 对于pair
    #include <iostream>
    #include <algorithm>
    #include <vector>
    #include <queue>
    
    using namespace std;
    
    int main(){
        typedef pair<int, int> PII;
        // priority_queue<PII> p; // 大根堆
        // p.push({100, 2});
        // p.push({300, 2});
        // p.push({2, 300});
        // cout << p.top().first << " " << p.top().second << endl; // 300 2
        
        priority_queue<PII, vector<PII>, greater<PII>> p; // 小根堆
        p.push({100, 2});
        p.push({300, 2});
        p.push({1, 200});
        p.push({2, 300});
        cout << p.top().first << " " << p.top().second << endl; // 1 200
        
    	return 0;
    }
    
    1. 对于结构体:

    大根堆

    struct Rec{
    	int a, b;
    	bool operator< (const Rec& t) const {// 有sort则必须运算符重载,具体:小根堆重载>,大根堆重载<
    		return a < t.a;
    	}
    };
    
    priority_queue<Rec> d; // 大根堆重载<,此处为大根堆
    

    小根堆

    struct Rec{
    	int a, b;
    	bool operator> (const Rec& t) const {// 有sort则必须运算符重载,具体:小根堆重载>,大根堆重载<
    		return a > t.a;
    	}
    };
    
    priority_queue<Rec, vector<Rec>, greater<Rec>> d; // 小根堆重载>,此处为小根堆
    

    e.g.

    #include <iostream>
    #include <algorithm>
    #include <vector>
    #include <queue>
    
    using namespace std;
    
    const int N = 1010;
    
    int main(){
        // struct Person{
        //     int a, b;
        //     bool operator< (const Person& t) const{
        //         return a < t.a;
        //     }
        // };
        
        // priority_queue<Person> p; // 大根堆
        // p.push({100, 2});
        // p.push({300, 2});
        // p.push({2, 300});
        // cout << p.top().a << " " << p.top().b << endl; // 300 2
        
        struct Person{
            int a, b;
            bool operator> (const Person& t) const{
                return a > t.a;
            }
        };
        
        priority_queue<Person, vector<Person>, greater<Person>> p; // 小根堆
        p.push({100, 2});
        p.push({300, 2});
        p.push({2, 300});
        cout << p.top().a << " " << p.top().b << endl; // 2 300
    	
    	return 0;
    }
    

    Java和python的处理方式

    另外,对于复杂元素的排序,整理Java和python的处理方式:

    Java

    1009: 1-2-1 Milking Cows 挤牛奶为例,
    基本思路是先转为列表List<>,再通过Collections.sort()处理:

    Collections.sort(list, new Comparator<单个元素的类型>() {
                //升序排序 若降序则交换o1,、o2顺序即可
                public int compare(元素类型 o1,
                                   元素类型 o2) {
                    return o1.getKey().compareTo(o2.getKey()); // 此处为元素的key或者其他属性值
                }
    
            });
    

    完整代码:

    import java.util.*;
    
    public class Main{
        public static int N = 5010;
        public static int n;
        public static int a, b;
        public static Map<Integer, Integer> map = new HashMap<>();
    
        public static void main(String[] args){
            Scanner scanner = new Scanner(System.in);
            n = scanner.nextInt();
            for(int i = 0; i < n; i ++ ){
                a = scanner.nextInt();b = scanner.nextInt();
                map.put(a, b);
            }
            // 对map的key进行排序(左端点)
            List<Map.Entry<Integer,Integer>> listOfMap = new ArrayList<Map.Entry<Integer,Integer>>(map.entrySet());// 取出集合再化为列表
            Collections.sort(listOfMap, new Comparator<Map.Entry<Integer,Integer>>() {
                //升序排序
                public int compare(Map.Entry<Integer, Integer> o1,
                                   Map.Entry<Integer, Integer> o2) {
                    return o1.getKey().compareTo(o2.getKey());
                }
    
            });
    //        System.out.println(listOfMap);
            Map.Entry<Integer,Integer> first = listOfMap.stream().findFirst().orElse( null );
    //        System.out.println(first);
            // 贪心
            int res1 = 0, res2 = 0;
            int l = first.getKey(), r = first.getValue();
            for(Map.Entry<Integer,Integer> item:listOfMap){
                if(item.getKey() <= r) r = Math.max(r, item.getValue());
                else{
                    res1 = Math.max(res1, r - l);
                    res2 = Math.max(res2, item.getKey() - r);
                    l = item.getKey();
                    r = item.getValue();
                }
            }
            res1 = Math.max(res1, r - l); // 最后一段别漏了
            System.out.println(res1 + " " + res2);
        }
    }
    

    python

    eg:p列表中的元素x也为列表,按照x的第一个元素进行排序:

    p = sorted(p, key = lambda x : x[0])
    
    展开全文
  • python的sort自定义排序

    2022-05-08 06:13:54
    sort(0, len(strs) - 1) return ''.join(strs) class Solution: def minNumber(self, nums: List[int]) -> str: def sort_rule(x, y): a, b = x + y, y + x if a > b: return 1 elif a [str(num) for num in nums] ...

    剑指 Offer 45. 把数组排成最小的数

    输入一个非负整数数组,把数组里所有数字拼接起来排成一个数,打印能拼接出的所有数字中最小的一个。

    示例 1:
    输入: [10,2]
    输出: "102"
    示例 2:

    输入: [3,30,34,5,9]
    输出: "3033459"

    提示:0 < nums.length <= 100

    class Solution:
        def minNumber(self, nums: List[int]) -> str:
            def quick_sort(l, r):
                if l >= r: return
                i, j = l, r 
                while i < j:
                    while strs[j] + strs[l] >= strs[l] + strs[j] and i < j: j -= 1
                    while strs[i] + strs[l] <= strs[l] + strs[i] and i < j: i += 1
                    strs[i], strs[j] = strs[j], strs[i]
                strs[i], strs[l] = strs[l], strs[i]
                quick_sort(l, i - 1)
                quick_sort(i + 1, r)
            
            strs = [str(num) for num in nums]
            quick_sort(0, len(strs) - 1)
            return ''.join(strs)
    class Solution:
        def minNumber(self, nums: List[int]) -> str:
            def sort_rule(x, y):
                a, b = x + y, y + x
                if a > b: return 1
                elif a < b: return -1
                else: return 0
            strs = [str(num) for num in nums]
            strs.sort(key=functools.cmp_to_key(sort_rule))
            return ''.join(strs)
    展开全文
  • Arrays.sort自定义排序规则

    lc周赛用到了自定义排序,简单整理一下

    假设compare的参数有两个,分别为o1和o2,compare方法的返回值有三个,分别是-1,0,1

    分别代表:
    -1: s1 < s2
    0 : s1 = s2
    1 : s1 > s2

    public static void main(String[] args) {
        String[][] strs = new String[][]{{"233", "0"}, {"132", "1"}, {"321", "2"}, {"121", "3"}};
        Arrays.sort(strs, test124325432::compare);
        for (int i = 0; i < strs.length; i++) {
            System.out.println("value = " + strs[i][0] + " idx = " + strs[i][1]);
        }
    }
    
    static int compare(String[] s1, String[] s2) {
        //  1 : s1 > s2
        //  0 : s1 = s2
        // -1 : s1 < s2
        for (int i = 0; i < s1[0].length(); i++) {
            char c1 = s1[0].charAt(i);
            char c2 = s2[0].charAt(i);
            if (c1 > c2) return 1;
            else if (c1 < c2) return -1;
        }
        return 0;
    }
    
    展开全文
  • //自定义排数方式 public class Arrays_paixu_test_Student { public static void main(String[] args) { Integer[] arr = {45,21,8,89,453,7}; Arrays.sort(arr, new Comparator() { //匿名内部类知识 @Override ...
  • C++中的sort自定义排序函数

    万次阅读 多人点赞 2019-01-24 09:14:31
    C++中sort自定义排序 1.sort简介: (1)用于C++中,对给定区间所有元素进行排序; (2)使用的排序方法是类似于快排的方法,时间复杂度为n*log2(n),执行效率较高; (3)头文件 #include &lt;algo...
  • 主要介绍了python3 sorted 如何实现自定义排序标准,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 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....
  • 74_sort自定义排序1

    2022-08-03 14:50:14
    系统会根据你的数据形式和数据量动选择合适的排序法,这并不是说它每次排序只选择种法,它是在次完整排序中不同的情况选不同法,如给个数据量较的数组排序,开始采快速排序
  • sort对于内置类型类型是升序排序,若要进行自定义排序有四种方法实现: - STL里的仿函数类。std::greater和std::less,他们在头文件\里,能对内置类型进行排序 - 自定义排序函数 - 仿函数类 - 重载operator<函数
  • 使用sort算法自定义排序的几种方法及类内实现出现的问题2. sort部分源码: 1. 使用sort算法自定义排序的几种方法及类内实现出现的问题 sort算法默认使用元素类型的 ‘<’ 运算符,但是当我们希望的排序顺序与 ...
  • 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....
  • 我第一次接触这个问题还是很久以前刚刚参加工作的时候,当时也是写出了导致程序崩溃的代码,通过上网查询解决了问题,至此以后就对这个 `sort` 函数警惕了一些,一直记得就是在sort自定义函数中判断条件不要加等号...
  • 【C++】sort自定义排序规则

    千次阅读 2019-07-03 14:51:28
    第三个参数compare,是个自定义的比较函数的指针,名字可以随便命名;原型如下: bool cmp (const Type1 &a,const Type2 & b ); 简单说来就是: 比较a和b,如果是想升序,那么就定义当a<b的时候返回true; ...
  • Collections.sort(totalCheckList, new Comparator() { // 重写排序规则 匿名内部类实现 @Override public int compare(InstCheck check1, InstCheck check2) {
  • sort函数自定义排序

    千次阅读 多人点赞 2020-12-15 18:09:29
    sort函数自定义排序 咳咳,自定义排序说实话用的地方还是很多的,像ACM里面,天梯赛里面,特别是天梯,必出这玩意。。。咳咳,水点字数,咱继续。 首先哈,我们来看一下c++自带的排序; 可以看出哈,默认是按...
  • STL中sort自定义排序

    2022-05-24 00:16:46
    STL中的sort自定义模板 vector<T> ve; bool cmp(const T &a,const T &b){ ........//写你要定义的排序函数 } 例子 假设一个场景,让你按成绩排序,并输出成绩和姓名,如果是结构体的写法的话应该是...
  • 这个解法很精妙,其中用到了sort自定义排序与lamda,借此回顾一下 进入正题 1.sort自定义排序 sort()排序函数是c++头文件include 中的函数,它采用的是一种类似于快排的排序方式,时间复杂度 n*log2(n)。...
  • C++使用sort函数进行自定义排序

    千次阅读 2022-04-07 19:36:03
    我们平时使用sort都是对一个数组进行从大到小或者从小到大排序,然而,有时候我们需要对一些特殊的数据进行我们想要的排序,就需要自定义一些比较函数用于排序,将这些比较函数作为sort函数的第三个参数,这样就可以...
  • 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()自定义排序

    2021-10-16 14:03:16
    sort()方法的底层采用归并排序,时间复杂度为O(nlgn),空间复杂度为O(n),感兴趣的同学自行查阅源码,本文仅说明使用sort()方法进行自定义排序时的注意点 代码 public class Test { static class Node{ String ...
  • sort自定义排序的尝试使用sort(first,last cmp) 自定义排序,这里sort在循环里面应该只执行两次,被设定成出现连续的date的值相等得时候才把这一组进行排序,排序之后的number依然遵从全体排序的0-9 sort(first,last...
  • sort函数对系统类型默认升序排列,当我们想降序排列或者对自定义数据类型排序时需要手写排序函数cmp,具体语句为sort(a.begin(),a.end(),cmp)。 在做leetcode501题目时,发现自定义sort排序函数报错:error: ...
  • 众所周知,javascript中的sort方法可以实现排序,但是如果只是使用默认的方法,很难拿到理想的结果,所以需要实现自定义排序
  • 1、默认排序 默认是升序排序less<typeName>...sort(vec.begin(), vec.end()); for (int v : vec) { cout << v << " "; } cout << endl; /* 输出为 1 2 3 4 5 6 */ //实例2 vec.
  • Python3 sort 自定义比较逻辑:lambda函数、可比较类、cmp_to_key默认排序方式lambda函数自定义可比较类通过cmp_to_key自定义比较逻辑 以字符串排序为例,现在我们有这样一个字符串的 list : words = ["vanilla", ...
  • Python3使用sort函数自定义排序

    千次阅读 2020-12-05 21:51:08
    直接使用sort()函数 score = [78, 90, 40, 60...根据数据中的某一个项排序 students = [{"age": 18, "name": 'jack', "score": 89}, {"age": 15, "name": 'tom', "score": 98}, {"age": 16, "name": 'mike', "score":
  • @[TOC](Java List sort() 排序示例 | 列表自定义排序) sort是java.util.List接口的默认方法。 List的排序方法在Java 8中被引入。 1. 排序方法接受比较器作为参数,并根据指定的比较器对这个列表进行排序。 default ...
  • sort 自定义排序使用方法

    千次阅读 2018-07-14 14:18:07
    sort()排序函数是c++头文件include &lt;algorithm&gt;中的函数,它采用的是一种类似于快排的排序方式,时间复杂度 n*log2(n)。可以对 浮点数,整数,字符,字符串,结构体进行排顺序,排序方法不限于从大到...
  • 使用Golang sort包实现自定义排序

    千次阅读 2020-08-10 09:07:50
    使用Golang sort包实现自定义排序 排序是每个程序员在工作比做的工作之一,有很多排序算法供你选择,通常我们会利用开发包提供的实现。本文学习使用sort包中的排序实现,在此基础上自定义排序函数实现对组合数据结构...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 143,163
精华内容 57,265
关键字:

sort自定义排序

友情链接: MASfarid.rar