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

莫浔

已于 2024-01-18 15:18:32 修改

阅读量631

点赞数 7

分类专栏： c++ 文章标签： c++ 算法开发语言

于 2024-01-16 14:39:30 首次发布

本文链接：https://blog.csdn.net/qq_41135605/article/details/135624132

版权

c++ 专栏收录该内容

13 篇文章 2 订阅

订阅专栏

文章目录

1 sort()使用自定义比较器
2 重载运算符<
- 2.1 在结构体中重载运算符<
- 2.2 在类中重载运算符<
3 重写仿函数bool operator()
4 使用pair排序
5 priority_queue自定义排序规则
6 关于priority_queue中存储pair类型的思考

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

头文件：#include <algorithm>
使用：sort(first,last,cmp);
first是元素的起始地址，last是结束地址，cmp是排序的方式。对[first，last)（一定要注意这里的区间是左闭又开）区间内数据根据cmp的方式进行排序。也可以不写第三个参数，此时默认按从小到大排序。
C++ STL 标准库中的 sort()函数本质就是一个模板函数。该函数专门用来对容器或普通数组中指定范围内的元素进行排序，对于自定义的类或结构体这种复杂数据类型，需要自定义排序规则。

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;
    };

输出：

这里一定要注意一下：

参数类型如果是自定义类型，比如自己定义的结构体，类，这里必须要重载比较运算符“<”!!!

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自定义排序规则

头文件

#include <queue>

定义

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种方式：

重载运算符<
重写仿函数
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，排序结果为降序。
建议在使用时按照priority_queue<Type, Container, Functional> varName来声明变量。

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或者sort()函数对自定义的数据类型，需要自定义排序规则。vector<pair<T1,T2>>显示调用std::sort能对每个元素按优先级排序。
如果使用 priority_queue<pair<T1, pair<T2, T3>>> date，很明显：在定义date时就已经指定了排序规则，只要把数据往date中放就保证了顺序，更简洁。
priority_queue结合pair有什么劣势?
priority_queue已经指定了pair中每个元素只能按升序或降序，但是如果碰到第一个元素升序，第二个元素降序，第三个元素降序，这样的情况下 priority_queue<pair<T1, pair<T2, T3>>> date显然不能实现，就需要自定义排序规则来解决了。

有其他观点关于评论区讨论~~~