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

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({1997, 9, 30});
    exam.push_back({1990, 1, 1});
    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;
    };

输出：

Hello Word!
before:[1997,8,19]; [1997,9,30]; [1990,1,1]; [1990,1,20];
after:[1990,1,1]; [1990,1,20]; [1997,8,19]; [1997,9,30];

这里一定要注意一下：

参数类型如果是自定义类型，比如自己定义的结构体，类，尽管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({1997, 9, 30});
    exam.push_back({1990, 1, 1});
    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({1997, 9, 30});
    exam.push_back({1990, 1, 1});
    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(1997, std::make_pair(9, 30)));
    vec.push_back(std::make_pair(1990, std::make_pair(1, 11)));
    vec.push_back(std::make_pair(1990, std::make_pair(1, 30)));

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

    std::sort(vec.begin(), vec.end());
    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种方式：

重载运算符<
重写仿函数

#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
    {
        // 重载<符号来比较日期的大小
        if (year == a.year) {
            if (month == a.month) {
                return day < a.day;
            } else {
                return month < a.month;
            }
        } else {
            return year < a.year;
        }
    }
};

struct myCompare  // 重写仿函数
{
    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({1997, 2, 5});
    vec_1.push({1990, 10, 9});
    vec_1.push({1990, 8, 9});

    priority_queue<date, vector<date>, myCompare> vec_2;
    vec_2.push({2007, 2, 22});
    vec_2.push({2007, 2, 5});
    vec_2.push({2000, 10, 9});
    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;
};