C++ 多条件比较的几种实现方式

文章目录

  • 1 sort()使用自定义比较器
    • 1.1 在类内部定义比较器 -- 声明为静态成员函数
    • 1.2 在函数内部定义比较器 -- lamda表达式
    • 1.3 全局函数比较器
  • 2 重载运算符<
    • 2.1 在结构体中重载运算符<
    • 2.2 在类中重载运算符<
  • 3 重写仿函数bool operator()
  • 4 使用pair排序
  • 5 priority_queue自定义排序规则
  • 6 关于priority_queue中存储pair类型的思考

1 sort()使用自定义比较器

sort使用方法
头文件 #include
sort函数有三个参数：
sort(first,last,cmp);
其中，first是元素的起始地址，last是结束地址，cmp是排序的方式。对[first，last)（一定要注意这里的区间是左闭又开）区间内数据根据cmp的方式进行排序。也可以不写第三个参数，此时按默认排序，从小到大进行排序。

sort() 中的比较函数 compare 要声明为静态成员函数或全局函数，不能作为普通成员函数，否则会报错。

cmpChar实现功能：大写字母大于小写字母，小写字母按 a-z 升序，大写字母按 A-Z 升序

1.1 在类内部定义比较器 – 声明为静态成员函数

class Solution {
public:
    void CharacterSort(const vector<char> e_char)
    {
      cout << "before:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;

        std::sort(e_char.begin(), e_char.end(), cmpChar);
        cout << "after:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;
    }

private:
    static bool cmpChar(const char &a, const char &b)
    {
        if (a <= 'Z' && b >= 'a')
            return false;
        else if (b <= 'Z' && a >= 'a')
            return true;
        else
            return a < b;
    }

};

输入：
vector e_char = {‘C’,‘B’,‘A’,‘c’,‘b’,‘a’};
输出：
before:
CBAcba
after:
abcABC

1.2 在函数内部定义比较器 – lamda表达式

class Solution {
public:
    void CharacterSort(const vector<char> e_char)
    {
      cout << "before:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;
        auto cmpChar = [](const char &a, const char &b) {
            if (a <= 'Z' && b >= 'a')
                return false;
            else if (b <= 'Z' && a >= 'a')
                return true;
            else
                return a < b;
        };

        std::sort(e_char.begin(), e_char.end(), cmpChar);
        cout << "after:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;
    }

1.3 全局函数比较器

using namespace std;

bool cmpChar(const char &a, const char &b)
    {
        if (a <= 'Z' && b >= 'a')
            return false;
        else if (b <= 'Z' && a >= 'a')
            return true;
        else
            return a < b;
    }

class Solution {
public:
    void CharacterSort(const vector<char> e_char)
    {
      cout << "before:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;

        std::sort(e_char.begin(), e_char.end(), cmpChar);
        cout << "after:" << endl;
        for (auto i : e_char) {
            cout << i;
        }
        cout << endl;
    }

2 重载运算符<

例子：按年月日升序排序。

2.1 在结构体中重载运算符<

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

using namespace std;

struct date {
    int year;
    int month;
    int day;
	
	//在结构体中重载运算符<
    bool operator<(const date &a) const
    {
        // 重载<符号来比较日期的大小
        if (year == a.year) {
            if (month == a.month) {
                return day < a.day;
            } else {
                return month < a.month;
            }
        } else {
            return year < a.year;
        }
    }
};
// 在结构体外部重载运算符<
/*
bool operator<(const date &a, const date &b)
{
    // 重载<符号来比较日期的大小
    if (a.year == b.year) {
        if (a.month == b.month) {
            return a.day < b.day;
        } else {
            return a.month < b.month;
        }
    } else {
        return a.year < b.year;
    }
}
*/

int main()
{
    cout << "Hello Word!\n";

    vector<date> exam;
    exam.push_back({1997, 8, 19});
    exam.push_back({1990, 1, 1});
    exam.push_back({1997, 9, 30});
    exam.push_back({1990, 1, 20});
    cout << "before:";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
    sort(exam.begin(), exam.end());
    cout << "\nafter:";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
    return 0;
    };

输出：

这里一定要注意一下：

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

2.2 在类中重载运算符<

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

using namespace std;

class date {
public:
    int year;
    int month;
    int day;
    // 在类内部重载运算符<
    bool operator<(const date &a)
    {
        // 重载<符号来比较日期的大小
        if (year == a.year) {
            if (month == a.month) {
                return day < a.day;
            } else {
                return month < a.month;
            }
        } else {
            return year < a.year;
        }
    }
};
// 在类外部重载运算符<
/*
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 main()
{
    cout << "Hello Word!\n";

    vector<date> exam;
    exam.push_back({1997, 8, 19});
    exam.push_back({1990, 1, 1});
    exam.push_back({1997, 9, 30});
    exam.push_back({1990, 1, 20});
    cout << "before:";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
    sort(exam.begin(), exam.end());
    cout << "\nafter: ";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
        return 0;
};

在这里插入图片描述

3 重写仿函数bool operator()

sort函数的默认比较函数std:less和std::greater，内部实现就是重载了运算符()。
在这里插入图片描述

int test[10] = {4, 1, 3, 7, 5, 8, 2, 9, 6, 10};
// 注意这里创建了greater对象，sort函数调用greater对象的()运算符重载方法
sort(test, test + 10, greater<int>());

这里首先调用的是greater类的默认构造方法，返回一个对象并传递给sort函数。sort函数内部调用对象(a,b)时调用的是对象的运算符()重载方法来进行比较。

这里重载了()运算符其实是构造了一个“伪函数”，也就是可以把类的对象作为函数来使用。

模仿greater和less模板类的定义，我们也可以自己定义比较器类:

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

using namespace std;

class date {
public:
    int year;
    int month;
    int day;
};

struct MyLess  // 自定义比较器类
{
    bool operator()(const date &a, const date &b) const
    {
        if (a.year == b.year) {
            if (a.month == b.month) {
                return a.day < b.day;
            } else {
                return a.month < b.month;
            }
        } else {
            return a.year < b.year;
        }
    }
};

int main()
{
    cout << "Hello Word!\n";

    vector<date> exam;
    exam.push_back({1997, 8, 19});
    exam.push_back({1990, 1, 1});
    exam.push_back({1997, 9, 30});
    exam.push_back({1990, 1, 20});
    cout << "before:";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
    sort(exam.begin(), exam.end(), MyLess());
    cout << "\nafter: ";
    for (auto e : exam) {
        cout << "[" << e.year << "," << e.month << "," << e.day << "]; ";
    }
	return 0;
};

在这里插入图片描述

4 使用pair排序

头文件：

#include <utility>  #pair头文件

定义：

pair<string,int> p; 
//① 将类型定义写在前面，后面用小括号内两个元素的方式。
pair<string,int>("haha",5)
//② 使用自带的 make_pair 函数。
make_pair("haha",5)

pair<typeName1,typeName2> name，可以是任意基本数据类型或容器。

pari的排序规则默认先比较第一个元素，第一个相等比较第二个。

#include <algorithm>
#include <iostream>
#include <vector>
#include <utility>

using namespace std;

int main()
{
    cout << "Hello Word!\n";

    std::vector<std::pair<int, std::pair<int, int>>> vec;
    
    vec.push_back(std::make_pair(1997, std::make_pair(8, 19)));
    vec.push_back(std::make_pair(1990, std::make_pair(1, 11)));
    vec.push_back(std::make_pair(1997, std::make_pair(9, 30)));
    vec.push_back(std::make_pair(1990, std::make_pair(1, 30)));

    cout << "\nbefore: ";
    for (auto e : vec) {
        std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";
    }
    cout << "\nless:   ";

    std::sort(vec.begin(), vec.end());
    for (auto e : vec) {
        std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";
    }

    cout << "\ngreater:";
    std::sort(vec.begin(), vec.end(), greater<std::pair<int, std::pair<int, int>>>());
    for (auto e : vec) {
        std::cout << e.first << "," << e.second.first << "," << e.second.second << "; ";
    }
    cout << std::endl;
	return 0;
};

在这里插入图片描述

5 priority_queue自定义排序规则

  1. 头文件
#include <queue>
  1. 定义
priority_queue<int> a;  //对于基础类型 默认是大顶堆
priority_queue<int, vector<int>, less<int> > a;  // 等同于priority_queue<int> a 
priority_queue<int, vector<int>, greater<int> > c;  //这样就是小顶堆

priority_queue<Type, Container, Functional>
Type为数据类型； Container为保存数据的容器（Container必须是用数组实现的容器，比如vector,deque等等，但不能用 list，STL里面默认用的是vector）；Functional为元素比较方式。
如果不写后两个参数，那么容器默认用的是vector，比较方式默认用operator<，也就是优先队列是大顶堆，队头元素最大。
当需要用自定义的数据类型时才需要传入这三个参数；

优先队列具有队列的所有特性，包括基本操作，只是在这基础上添加了内部的一个排序，它本质是一个堆实现的。

3 自定义排序规则
priority_queue使用自定义的数据类型，同时也要实现自定义排序规则，有2种方式：

  1. 重载运算符<
  2. 重写仿函数
    priority_queue自定义排序规则，返回true要交换位置，这与前面提到的几种排序返回true不一样，容易记错。
#include <algorithm>
#include <iostream>
#include <vector>
#include <queue>

using namespace std;

struct date {
    int year;
    int month;
    int day;
    // 重载运算符<
    bool operator<(const date &a) const
    {
        // 重载<符号来比较日期的大小,返回true交换位置
        if (year == a.year) {
            if (month == a.month) {
                return day < a.day;
            } else {
                return month < a.month;
            }
        } else {
            return year < a.year;
        }
    }
};

struct myCompare  // 重写仿函数,返回true交换位置
{
    bool operator()(const date &a, const date &b) const
    {
        if (a.year == b.year) {
            if (a.month == b.month) {
                return a.day < b.day;
            } else {
                return a.month < b.month;
            }
        } else {
            return a.year < b.year;
        }
    }
};

int main()
{
    cout << "Hello Word!\n";

    priority_queue<date> vec_1;
    vec_1.push({1997, 2, 22});
    vec_1.push({1990, 10, 9});
    vec_1.push({1997, 2, 5});
    vec_1.push({1990, 8, 9});

    priority_queue<date, vector<date>, myCompare> vec_2;
    vec_2.push({2007, 2, 22});
    vec_2.push({2000, 10, 9});
    vec_2.push({2007, 2, 5});
    vec_2.push({2000, 8, 9});
    cout << "\noperator< : ";
    while (!vec_1.empty()) {
        std::cout << vec_1.top().year << ","<<vec_1.top().month<< ","<<vec_1.top().day<< ";";
        vec_1.pop();
    }

    cout << "\noperator(): ";
    while (!vec_2.empty()) {
        std::cout << vec_2.top().year << ","<<vec_2.top().month<< ","<<vec_2.top().day<< ";";
        vec_2.pop();
    }
    cout << std::endl;
    	return 0;
};

在这里插入图片描述

6 关于priority_queue中存储pair类型的思考

当priority_queue不指定排序方式是默认是大根堆（降序），pair默认std::less（升序），但如果priority_queue存储的是pair类型的时候呢？
先说结论：priority_queue<pair<int, int>> myqueue，排序结果为降序.

int main()
{
    cout << "Hello Word!\n";
    priority_queue<pair<int, int>> myqueue;
    //若插入数据类型的构造函数接受多个参数，push只接受该类型的实例，emplace不仅能接受该类型的实例，还能接受该类型构造函数的参数。
    myqueue.push({1990, 7});
    myqueue.emplace(1997, 7);
    myqueue.emplace(2000, 8);
    myqueue.emplace(2000, 9);
    myqueue.emplace(1000, 7);
    while (!myqueue.empty()) {
        cout << myqueue.top().first << " " << myqueue.top().second << endl;
        myqueue.pop();
    }
return 0;
};

在这里插入图片描述

有的文章提到优先队列priority_queue中使用pair，个人觉得使用一种就行，priority_queue结合pair有什么优势欢迎评论区留言。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/329494.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

基于Mapbox的Mvt矢量瓦片集成实践

基于Mapbox的Mvt矢量瓦片集成实践

目录 前言 一、数据说明 1、基本数据 2、属性数据 二、Mapbox集成Mvt矢量瓦片 1、关于访问令牌 2、定义html 3、初始地图 4、加载矢量瓦片 5、效果展示 总结 前言 熟悉矢量瓦片的朋友一定知道&#xff0c;在Webgis当中&#xff0c;矢量瓦片的格式除了pbf的格式&#x…
阅读更多...
Mysql 安装通过mysql installer安装+配置环境+连接可视化工具

Mysql 安装通过mysql installer安装+配置环境+连接可视化工具

注意&#xff1a;不适合纯小白&#xff0c;小白建议移步别的大佬MySQL详细安装教程 目录 注意&#xff1a;不适合纯小白&#xff0c;小白建议移步别的大佬MySQL详细安装教程 前言 准备工作 一、Mysql下载 二、MySQL installer 安装以及系统环境配置 三、检验MySQL 四、可…
阅读更多...
CleanMyMac X .4.14.7如何清理 Mac 系统？

CleanMyMac X .4.14.7如何清理 Mac 系统？

细心的用户发现苹果Mac电脑越用越慢&#xff0c;其实这种情况是正常的&#xff0c;mac电脑用久了会产生很多的缓存文件&#xff0c;如果不及时清理会影响运行速度。Mac系统在使用过程中都会产生大量系统垃圾&#xff0c;如不需要的系统语言安装包&#xff0c;视频网站缓存文件&…
阅读更多...
宝塔发布网站问题汇总和记录

宝塔发布网站问题汇总和记录

1、添加网站站点后打不开 解决办法&#xff0c;关闭防跨站攻击2 2、laravel项目部署到linux的时候出现The stream or file "/home/www/storage/logs/laravel.log" could not be opened in append mode 给目录加权限 chmod -R 777 storage 3、Class "Redis"…
阅读更多...
交友系统程序开发，前后端源码交付，允许二开，UI配色新颖，APP小程序H5随心搭配！

交友系统程序开发，前后端源码交付，允许二开，UI配色新颖，APP小程序H5随心搭配！

在开发设计与测试阶段&#xff0c;主要包括了程序开发、测试和上线运营等环节。根据产品经理确定的功能需求&#xff0c;开发团队开始进行具体的编程和开发工作。这个过程中需要考虑到不同设备、不同系统和不同版本的需求&#xff0c;确保软件可以在不同平台上稳定运行。 测试是…
阅读更多...
在线录屏-通过Web API接口轻松实现录屏

在线录屏-通过Web API接口轻松实现录屏

在线录屏是指在互联网上进行屏幕录制的过程。它允许用户通过网络连接&#xff0c;将自己的屏幕活动记录下来&#xff0c;并可以在需要时进行播放、共享或存档。在线录屏常用于教育、培训、演示、游戏等场景&#xff0c;可以帮助用户展示操作步骤、解决问题、分享经验等。通常&a…
阅读更多...
MySQL运维篇（三）分库分表

MySQL运维篇（三）分库分表

一、介绍 1. 问题分析 随着互联网及移动互联网的发展&#xff0c;应用系统的数据量也是成指数式增长&#xff0c;若采用单数据库进行数据存储&#xff0c;存在以下 性能瓶颈&#xff1a; &#xff08;1&#xff09;IO瓶颈&#xff1a;热点数据太多&#xff0c;数据库缓存不足&…
阅读更多...
Redis的事务

Redis的事务

一、Redis中事务的定义 1) Redis事务是一个单独的隔离操作&#xff1a;事务中的所有命令都会序列化、按顺序地执行。事务在执行的过程中&#xff0c;不会被其他客户端发送来的命令请求所打断 2) Redis事务的主要作用就是串联多个命令防止别的命令插队。 二、multi 、exe…
阅读更多...
高精度算法笔记·····························

高精度算法笔记·····························

目录 加法 减法 乘法 除法 高精度加法的步骤&#xff1a; 1.高精度数字利用字符串读入 2.把字符串翻转存入两个整型数组A、B 3.从低位到高位&#xff0c;逐位求和&#xff0c;进位&#xff0c;存余 4.把数组C从高位到低位依次输出 1.2为准备 vector<int> A, B, …
阅读更多...
vite 打包优化

vite 打包优化

✨专栏介绍 在当今数字化时代&#xff0c;Web应用程序已经成为了人们生活和工作中不可或缺的一部分。而要构建出令人印象深刻且功能强大的Web应用程序&#xff0c;就需要掌握一系列前端技术。前端技术涵盖了HTML、CSS和JavaScript等核心技术&#xff0c;以及各种框架、库和工具…
阅读更多...
消息中间件面试题

消息中间件面试题

目录 一.为什么使用消息队列 二.RabbitMQ 1.RabbitMQ如何保证消息不丢失 2.RabbitMQ消息的重复消费问题 3.RabbitMQ延迟队列 4.RabbitMQ消息堆积 5.RabbitMQ高可用机制 三.Kafka 1.Kafka如何保证消息不丢失 2.Kafka如何保证消费消息的顺序性 3.Kafka高可用机制 4.Ka…
阅读更多...
GitLab Runner 实现项目 CI/CD 发布

GitLab Runner 实现项目 CI/CD 发布

Gitlab Runner简介 Gitlab实现CICD的方式有很多&#xff0c;比如通过Jenkins&#xff0c;通过Gitlab Runner等&#xff0c;今天主要介绍后者。Gitlab在安装的时候&#xff0c;就默认包含了Gitlab CI的能力&#xff0c;但是该能力只是用于协调作业&#xff0c;并不能真的去执行…
阅读更多...
PLSQL去除一个字符串中的数字

PLSQL去除一个字符串中的数字

PLSQL去除一个字符串中的数字 SQL Select regexp_replace(abc1234ABC678aaad590AAA, [0-9], ) As 去数字后From dual;效果
阅读更多...
Web开发介绍

Web开发介绍

1 什么是web开发 Web&#xff1a;全球广域网&#xff0c;也称为万维网(www World Wide Web)&#xff0c;能够通过浏览器访问的网站。 所以Web开发说白了&#xff0c;就是开发网站的&#xff0c;例如下图所示的网站&#xff1a;淘宝&#xff0c;京东等等 那么我们知道了web开发…
阅读更多...
【Linux】Linux 系统编程——touch 命令

【Linux】Linux 系统编程——touch 命令

文章目录 1.命令概述2.命令格式3.常用选项4.相关描述5.参考示例 1.命令概述 在**Linux 中&#xff0c;每个文件都与时间戳相关联&#xff0c;每个文件都存储了上次访问时间、**上次修改时间和上次更改时间的信息。因此&#xff0c;每当我们创建新文件并访问或修改现有文件时&a…
阅读更多...
1.17 day4 IO网络编程

1.17 day4 IO网络编程

用udp实现tftp下载和上传功能 #include <myhead.h> #define PORT 69 #define IP "192.168.122.24" int shangchuan(int sfd,struct sockaddr_in sin,socklen_t socklen) {int cfd-1;if((cfdopen("./01udpk.c",O_RDONLY))-1){perror("open erro…
阅读更多...
Python算法例36 丑数Ⅱ

Python算法例36 丑数Ⅱ

1. 问题描述 设计一个算法&#xff0c;找出只含素因子2、3、5的第n小的数&#xff0c;符合条件的数如&#xff1a;1、2、3、4、5、6、8、9、10、12… 2. 问题示例 如果n9&#xff0c;返回10。 3. 代码实现 def find_nth_number(n):if n < 0:return Nonenumbers [1]idx…
阅读更多...
SpringBoot项目如何优雅的实现操作日志记录

SpringBoot项目如何优雅的实现操作日志记录

SpringBoot项目如何优雅的实现操作日志记录 前言 在实际开发当中&#xff0c;对于某些关键业务&#xff0c;我们通常需要记录该操作的内容&#xff0c;一个操作调一次记录方法&#xff0c;每次还得去收集参数等等&#xff0c;会造成大量代码重复。 我们希望代码中只有业务相关…
阅读更多...
React16源码: React中的异步调度scheduler模块的源码实现

React16源码: React中的异步调度scheduler模块的源码实现

React Scheduler 1 ) 概述 react当中的异步调度&#xff0c;称为 React Scheduler发布成单独的一个 npm 包就叫做 scheduler这个包它做了什么&#xff1f; A. 首先它维护时间片B. 然后模拟 requestIdleCallback 这个API 因为现在浏览器的支持不是特别的多所以在浏览当中只是去…
阅读更多...
【Dynamo学习笔记】Dynamo for Revit建模基础

【Dynamo学习笔记】Dynamo for Revit建模基础

目录 前言1 Revit模型的结构2 图元的操作2.1 图元的选择2.2 图元参数的读取和写入2.3 图元的创建2.3.2 创建轴网2.3.2 创建结构柱2.3.3 创建结构框架2.3.4 创建墙体 3 自定义节点 参考资料&#xff1a; &#xff08;1&#xff09; 罗嘉祥&#xff0c;宋姗&#xff0c;田宏钧. 《…
阅读更多...
最新文章

Copyright @ 2022~2023