比较器(C++/Java)

已于 2022-04-10 13:35:21 修改
阅读量3k 收藏 25
点赞数 6
文章标签： 比较器 c++
于 2021-07-10 13:01:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43536978/article/details/118632978
版权

比较器解决排序问题

比较器–C++/Java实现

对于任意比较器，对 返回值 都有统一的规范：

返回值 < 0 : <0: <0: o 1 o1 o1 排在 o 2 o2 o2 前面
返回值 > 0 : >0: >0: o 2 o2 o2 排在 o 1 o1 o1 前面
返回值 = 0 : =0: =0: 谁排前面都可以

实例1

C++:

//降序
bool compare(int a,int b){
	return a>b;
}
sort(arr.begin(),arr.end(),compare);

C++ Lambda表达式

std::sort(ans.begin(),ans.end(),[&](vector<int>& v1,vector<int>& v2){
            return (std::abs(v1[0]-rCenter)+std::abs(v1[1]-cCenter))<
            (std::abs(v2[0]-rCenter)+std::abs(v2[1]-cCenter));
        });

Java:

A r r a y s . s o r t ( ) Arrays.sort ( ) Arrays.sort() 默认升序，定义比较器而不用重新写就可以实现降序

import java.util.Arrays;

public class Comparator {

	public static void main(String[] args) {
		int[] arr= {1,0,9,6,2,5,6,7,2,5};
		Arrays.sort(arr);
		System.out.println(Arrays.toString(arr));
	}
}

在这里插入图片描述

import java.util.Arrays;
import java.util.Comparator;

public class MyComparator {
	public static class Compare implements Comparator<Integer>{
		@Override
		public int compare(Integer o1, Integer o2) {
			return o2-o1;
		}
	}
	public static void main(String[] args) {
		Integer[] arr= {1,0,9,6,2,5,6,7,2,5};
		Arrays.sort(arr,new Compare());
		System.out.println(Arrays.toString(arr));
	}
}

在这里插入图片描述


实例2

定义学生类，按照 I D ID ID 升序

C++:


#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
class Student{
public:
	Student(string myName,int myId,int myAge):name(myName),id(myId),age(myAge){}
	void outPut(){
		cout<<name<<" "<<id<<" "<<age<<endl;
	}
	string getName(){
		return name;
	}
	int getId(){
		return id;
	}
	int getAge(){
		return age;
	} 
private:
	string name;
	int id;
	int age;
};
//比较器 
bool compare(Student s1,Student s2){
    return s1.getId()<s2.getId();
}
void print(const vector<Student>& arr){
    for(auto k:arr){
    	k.outPut();
	}
}

int main(){
	vector<Student>arr;
//	Student tmp;
	int len=5;
	for(int i=0;i<len;++i){
		string name;
		int id;
		int age;
		cin>>name>>id>>age;
		Student stu(name,id,age);
		arr.push_back(stu);
	}
	sort(arr.begin(),arr.end(),compare);
	print(arr);
}


/*John 2001 23
Mary 2008 21
Hun 2003 29
Wu 2002 24
Ma 2005 22
======================
John 2001 23
Wu 2002 24
Hun 2003 29
Ma 2005 22
Mary 2008 21*/

Java:

import java.util.Arrays;
import java.util.Comparator;

public class MyComparator {
	public static class Student{
		public String name;
		public int ID;
		public int age;
		Student(String name,int ID,int age){
			this.name=name;
			this.ID=ID;
			this.age=age;
		}
	}
	public static class Compare implements Comparator<Student>{
		@Override
		public int compare(Student o1, Student o2) {
			return o1.ID-o2.ID;
		}
	}
	public static void main(String[] args) {
		Student[] stus=new Student[5];
		stus[0]=new Student("John", 2001, 23);
		stus[1]=new Student("Mary", 2008, 21);
		stus[2]=new Student("Hun", 2003, 29);
		stus[3]=new Student("Wu", 2002, 24);
		stus[4]=new Student("Ma", 2005, 22);
		Arrays.sort(stus,new Compare());
		for(int i=0;i<stus.length;++i) {
			System.out.println(stus[i].name+" "+stus[i].ID+" "+stus[i].age);
		}
	}
}

在这里插入图片描述

实例3

按照班级升序，按照年龄降序

C++:

//按照班级升序，按照年龄降序
#include<iostream>
#include<stdio.h>
#include<vector>
#include<algorithm>
using namespace std;
class Student{
public:
	Student(string myName,int myId,int myClass,int myAge):name(myName),id(myId),Class(myClass),age(myAge){}
	void outPut(){
		cout<<name<<" "<<id<<" "<<Class <<" "<<age<<endl;
	}
	string getName(){
		return name;
	}
	int getId(){
		return id;
	}
	int getClass(){
		return Class;
	}
	int getAge(){
		return age;
	} 
private:
	string name;
	int id;
	int Class;
	int age;
};
//比较器 
bool compare(Student s1,Student s2){

	if(s1.getClass()!=s2.getClass()){
		return s1.getClass()<s2.getClass();
	}
	return s1.getAge()>s2.getAge();
}
void print(const vector<Student>& arr){
    for(auto k:arr){
    	k.outPut();
	}
}

int main(){
	vector<Student>arr;
//	Student tmp;
	int len=5;
	for(int i=0;i<len;++i){
		string name;
		int id;
		int Class;
		int age;
		cin>>name>>id>>Class>>age;
		Student stu(name,id,Class,age);
		arr.push_back(stu);
	}
	sort(arr.begin(),arr.end(),compare);
	print(arr);
}

John 2008 1901 23
Wu 2002 1904 24
Hun 2003 1906 29
Ma 2005 1908 22
Mary 2001 1901 21
======================

John 2008 1901 23
Mary 2001 1901 21
Wu 2002 1904 24
Hun 2003 1906 29
Ma 2005 1908 22

*/

Java:

import java.util.Arrays;
import java.util.Comparator;

public class MyComparator {
	public static class Student{
		public String name;
		public int ID;
		public int age;
		public int classNo;
		Student(String name,int ID,int age,int classNo){
			this.name=name;
			this.ID=ID;
			this.age=age;
			this.classNo=classNo;
		}
	}
	public static class Compare implements Comparator<Student>{
		@Override
		public int compare(Student o1, Student o2) {
			if(o1.classNo!=o2.classNo) {
				return o1.classNo-o2.classNo;
			}
			return o2.age-o1.age;
		}
	}
	public static void main(String[] args) {
		Student[] stus=new Student[7];
		stus[0]=new Student("Mary", 2007, 25,1908);
		stus[1]=new Student("John", 2008, 23,1901);
		stus[2]=new Student("Wu", 2002, 24,1904);
		stus[3]=new Student("Mar", 2011, 19,1908);
		stus[4]=new Student("Hun", 2003, 29,1906);
		stus[5]=new Student("Ma", 2005, 22,1908);
		stus[6]=new Student("Mary", 2001, 21,1901);
		Arrays.sort(stus,new Compare());
		for(int i=0;i<stus.length;++i) {
			System.out.println(stus[i].name+" "+stus[i].classNo+" "+stus[i].age+" "+stus[i].ID);
		}
	}
}

在这里插入图片描述


实例4

自定义类型的堆，堆的组织结构是基于比较的，必须提供自定义类型的比较规则，这就可以用到比
较器。

按照年龄组织成小根堆

import java.util.Arrays;
import java.util.Comparator;
import java.util.PriorityQueue;

public class MyComparator {
	public static class Student{
		public String name;
		public int ID;
		public int age;
		public int classNo;
		Student(String name,int ID,int age,int classNo){
			this.name=name;
			this.ID=ID;
			this.age=age;
			this.classNo=classNo;
		}
	}
	public static class Compare implements Comparator<Student>{
		@Override
		public int compare(Student o1, Student o2) {
			return o1.age-o2.age;
		}
	}
	public static void main(String[] args) {
		Student[] stus=new Student[7];
		stus[0]=new Student("Mary", 2007, 25,1908);
		stus[1]=new Student("John", 2008, 23,1901);
		stus[2]=new Student("Wu", 2002, 24,1904);
		stus[3]=new Student("Mar", 2011, 19,1908);
		stus[4]=new Student("Hun", 2003, 29,1906);
		stus[5]=new Student("Ma", 2005, 22,1908);
		stus[6]=new Student("Mary", 2001, 21,1901);
		PriorityQueue<Student> heap=new PriorityQueue<Student>(new Compare());
		heap.add(stus[0]);
		heap.add(stus[1]);
		heap.add(stus[2]);
		heap.add(stus[3]);
		heap.add(stus[4]);
		heap.add(stus[5]);
		heap.add(stus[6]);
		while(!heap.isEmpty()) {
			Student s=heap.poll();
			System.out.println(s.name+" "+s.age+" "+s.classNo+" "+s.ID);
		}
	}
}

在这里插入图片描述




题目1

在这里插入图片描述

#include <iostream>
#include<stdio.h>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
class GDP{
	public:
	string city;
	double first;
	double second;
	double third;
	double ratio;
	double sum;
	GDP(string s,double a,double b,double c){
		city=s;
		first=a;
		second=b;
		third=c;
		ratio=c/(a+b+c); 
		sum=a+b+c;
	}
};
//比较器 
bool compare(GDP s1,GDP s2){
    return s1.sum>s2.sum;
}
bool compare1(GDP s1,GDP s2){
    return s1.ratio>s2.ratio;
}
int main() {
	int N;
	cin>>N;
	vector<GDP>vec;
	for(int i=0;i<N;++i){
		string s;double a,b,c;
		cin>>s>>a>>b>>c;
		GDP gdp(s,a,b,c);
		vec.push_back(gdp);
	}
	sort(vec.begin(),vec.end(),compare);
	cout<<vec[0].city<<" ";
	sort(vec.begin(),vec.begin()+3,compare1);
	cout<<vec[0].city<<" ";
}


Lambda表达式定义比较器

在这里插入图片描述
在这里插入图片描述

class Solution {
public:
    vector<vector<int>> allCellsDistOrder(int rows, int cols, int rCenter, int cCenter) {
        vector<vector<int>>ans;
        for(int i=0;i<rows;++i){
            for(int j=0;j<cols;++j){
                vector<int>v;
                v.push_back(i);
                v.push_back(j);
                ans.push_back(v);
            }
        }
        std::sort(ans.begin(),ans.end(),[&](vector<int>& v1,vector<int>& v2){
            return (std::abs(v1[0]-rCenter)+std::abs(v1[1]-cCenter))<
            (std::abs(v2[0]-rCenter)+std::abs(v2[1]-cCenter));
        });
        
        return ans;
    }
};

在这里插入图片描述



重新排列日志文件

在这里插入图片描述

在这里插入图片描述

class Solution {
public:
    static bool compare(string s1,string s2){
        
        int i=0;
        while(s1[i]!=' '){
            i++;
        }
        int j=0;
        while(s2[j]!=' '){
            j++;
        }
        string tmp1=s1.substr(i+1,s1.length());
        string tmp2=s2.substr(j+1,s2.length());
        if(tmp1==tmp2){
            return s1.substr(0,i)<s2.substr(0,j);
        }else{
            return tmp1<tmp2;
        }

    } 
    vector<string> reorderLogFiles(vector<string>& logs) {
        vector<string>letter;
        vector<string>number;
        for(string s:logs){
            if(s[s.length()-1]>='0'&&s[s.length()-1]<='9'){
                number.push_back(s);
            }else{
                letter.push_back(s);
            }
        }
        sort(letter.begin(),letter.end(),compare);
        for(string s:number){
            letter.push_back(s);
        }
        return letter;
    }
};

在这里插入图片描述



C++狂粉
关注
  • 6
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++ std::sort使用自定义的比较函数排序
wjjontheway的专栏
08-02 882
使用sort对容器进行排序，自定义升序降序函数，并且在类中使用Lambda表达式
sort算法排序 std_[C++]std::sort()函数使用总结
weixin_28729173的博客
01-17 1009
函数声明template< class RandomIt, class Compare >constexpr void sort( RandomIt first, RandomIt last, Compare comp );以一定排序规则排序指定范围内的元素，但是算法不具有稳定性，如果元素的值是相同的话不保证它们的相对顺序保持不变。参数说明first , last -要排序的元素范围。...
如何利用std::sort()完成升序和降序
最新发布
weixin_67856277的博客
05-06 724
是C++标准库中的一个函数，用于对给定范围内的元素进行排序。它可以接受一个数组、向量或其他容器，并按照默认的升序方式对元素进行排序。在上述示例中，函数接受两个迭代器作为参数，表示要排序的范围。对于数组，可以使用指针运算来指定范围；对于向量，可以使用.begin()和.end()方法来获取范围。默认情况下，使用"小于"运算符（）来比较元素并进行排序。
C++ STL set详解
qq_34999565的博客
03-23 2531
template< class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> > class set; std::set是一种关联型容器，是一个排序集合，可以用来存放Key类型的对象。set集合里的对象都是唯一的，所以通常可以用set来做去重。其中排序是通过Compare这个对比函数对象来完成的，因为要排序，对于自定义类型需要告诉编译器这个...
c++ 自定义 比较器 priority_queue_PriorityQueue是什么? 看过后才知道原来这么简单!
weixin_39861054的博客
11-23 253
上篇文章里我们了解到ArrayDeque是Queue的实现,而PriorityQueue是Queue的一种变体实现.在刷算法题的时候经常能用到,今天来讲讲PriorityQueue.概述我们都知道Queue是一个先进先出的队列,而PriorityQueue则是在队列的基础上增加了优先级的特性,是一个基于小顶堆的无解队列.举个栗子:在游乐园门口有很多人在排队进场,这就是一个...
C++中的Lambda函数
热门推荐
weixin_42887343的博客
12-23 1万+
一 函数语法 我们平时调用函数的时候，都是需要被调用函数的函数名，但是匿名函数就不需要函数名，而且直接写在需要调用的地方，对于以前没用过的小伙伴来说，第一眼看见了这语法可能很迷惑。 C++11的基本语法格式为： [capture](parameters) -> return_type { /* ... */ } （1） [capture] ：[]内为外部变量的传递方式，值、引用等，如下 [] //表示的是在lambda定义之前的域，对外部参数的调用； [=] //表示外部参
面向对象编程C++和Java比较教程
06-10
1. C++有指针，可以直接操作内存，而Java没有裸指针，使用引用来代替，内存管理由垃圾回收器自动进行。 2. C++有预处理器宏，而Java没有，这使得Java更易于理解和调试，但C++的宏在某些场合提供了更大的灵活性。 3. ...
C++ java语言转换器
12-09
C++ java语言转换器，个人感觉比较鸡肋，不如自己写，做备份用
词法分析器实现（java和c++）
01-18
4. **编程语言特性**：比较Java和C++在实现词法分析器时的差异，比如内存管理、异常处理和性能特性。 5. **编译器工具链**：如果使用Flex，你需要了解如何使用此工具生成词法分析器的C++代码。 6. **测试和调试**...
C++写的java词法分析器
04-28
在这个场景中，我们讨论的是一个用C++实现的Java词法分析器。 C++是一种强大的、通用的编程语言，以其性能和灵活性著称，被广泛用于系统编程、游戏开发、嵌入式系统以及各种复杂的软件工具，包括编译器和解析器的...
详解JAVA和C++的区别
08-20
Java 是一种解释性语言，Java 程序在运行时，类加载器从类路径中加载相关的类，然后 Java 虚拟机读取该类文件的字节，执行相应操作。相比之下，C++ 是一种编译语言，在编译时将程序编译成本地机器码。这种差异导致 ...
代码比较器
12-06
代码比较器，让你查看你的代码的不同之处。
C++比较器
qq_44742941的博客
03-24 1812
bool custom_compare(int a, int b) { int binary_count_a =0,binary_count_b=0,a_mid=a,b_mid=b; while(a) {binary_count_a ++;a &=a-1;} while(b) {binary_count_b ++;b &=b-1;} if(binary_count_a<binary_count_b) return true; el...
简单理解比较器comparator的compareTo返回值
安洁莉娅丶的博客
02-06 2663
本文参考：此处 在写比较器的时候老是纠结与到底哪个返回值是升序（从小到大），哪个返回值是降序（从大到小）。 翻找源码，可以知道Comparator本质上是个交换（swap） for (int j=i; j>low && c.compare(dest[j-1], dest[j])>0; j--) swap(dest, j, j-1); 上述代码的意思是，当dest[j-1] - dest[j] > 0时，就交换两个元素。 这样做
【c++】结构体sort排序，在类中调用自定义compare函数的正确姿势
weixin_44340194的博客
06-13 1789
众所周知，使用sort算法+自定义compare函数对自定义结构体进行排序： struct NumCount { int num, count; NumCount(int n,int c):num(n),count(c){} }; bool compare2(NumCount* a, NumCount* b) { return a->num < b->num; } void printNcs2(const vector<NumCount*>& ncs) { fo
c++11版本list中sort用lambda表达式
borderLands
07-09 4284
//定义学生类 class Student { public: string StuName; //姓名 string StuNum; //学号 string Sex; //性别 //成绩 float English; //英语 float SQL; //SQL float Prob; //概率论 float Circuit; //电路 float CSharp; //C#
java 比较器 返回值_Java Comparator reversed()用法及代码示例
weixin_39649478的博客
02-28 1480
Java中Comparator Interface的reversed()方法返回一个比较器，该比较器强加此比较器的相反顺序。如果您使用array的sort方法，并在应用反向方法后传递此比较器，则它将以相反的顺序对数组进行排序。用法:default Comparator reversed()参数：此方法不接受任何内容。返回值：该方法返回一个比较器，该比较器强加了此比较器的相反顺序。以下示例程序旨在说...
C++与Java异常与垃圾收集深度解析：面向对象编程比较
本文档是一份详细的面向对象编程C++与JAVA比较教程，着重讨论了异常处理和垃圾收集这两个核心主题。首先，异常在两种语言中的处理方式被深入剖析： 1. 异常的分类：C++和Java都支持异常处理，但可能有不同的分类...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值