力扣方法总结：排序

lambda表达式

自定义排序规则时常需要使用lambda表达式构建匿名函数，这里给出其语法和常用用法。

[capture list] (parameters) mutable throw() -> return-type { statement } 
[捕获列表]      (参数列表)    可变规则 异常说明() -> 返回类型    {函数体}

1. 捕获列表，常用[=] [&]，前者表示函数体内可使用Lambda所在范围内所有可见的局部变量，传递方式为值传递，后者为引用方式传递。详见
2. 参数列表如果没有可以省略，参数可以通过按值(int a, int b)方式和按引用(int& a, int& b)两种方式进行传递。
3. 可变规则和异常说明通常省略。
4. 返回值类型在编译器可以自动推导时，可以省略。
5. 函数体不能省略，但可以为空。

常用用法

1. QT中槽函数，特点：参数列表为空，无返回值。

connect(ui->button, &QPushButton::clicked(), this, [=](){...;});

2. 容器自定义排序规则，特点：捕获列表为空，参数列表以引用方式传递，返回bool类型。
   以下三种写法效果相同，分别是lambda表达式、函数对象、仿函数作为排序规则。

sort(v.begin(), v.end(), [](int& a, int& b){return a > b;});

bool cmp(int& a,int& b)
{
    return a > b;
}
sort(v.begin(), v.end(), cmp);

class cmp
{
	bool operator()(int& a, int& b) {
		return a > b;
	}
};
sort(v.begin(), v.end(), cmp());

比较自定义数据类型

class Person {
public:
	int age;
	string name;
	Person(int age, string name) {
        this->age = age;
        this->name = name;
    }
};

sort(p.begin(), p.end(), [](Person& p1, Person& p2) {return p1.age > p2.age;});

自定义数据类型已重载<运算符

class Person {
public:
	int age;
	string name;
    Person(int age, string name) {
        this->age = age;
        this->name = name;
    }
	bool operator< (const Person& p) const {
		return this.age > p.age;
	}
};

sort(p.begin(), p.end());

---

剑指 Offer II 074.合并区间 自定义排序 2023/3/23

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。
示例：
输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

首先将区间排序，排序规则为按第一个值从小到大排，再从头每两个比较其区间的大小并合并。

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.size() == 1) return intervals;
        sort(intervals.begin(), intervals.end(), [](vector<int>& i1, vector<int>& i2) {
            return i1[0] < i2[0]; // 按第一个值从小到大排
        });
        vector<vector<int>> res;
        for (int i = 0; i < intervals.size() - 1; i++) {
            // 可以合并
            if (intervals[i][1] >= intervals[i + 1][0]) {
                intervals[i + 1][0] = intervals[i][0];
                intervals[i + 1][1] = max(intervals[i + 1][1], intervals[i][1]);
            }
            // 不能合并
            else res.push_back(intervals[i]);
        }
        res.push_back(intervals.back());
        return res;
    }
};

---

剑指 Offer II 075.数组相对排序 自定义排序 2023/3/23

给定两个数组，arr1 和 arr2，
arr2 中的元素各不相同
arr2 中的每个元素都出现在 arr1 中
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。
示例：
输入：arr1 = [2,3,1,3,2,4,6,7,9,2,19], arr2 = [2,1,4,3,9,6]
输出：[2,2,2,1,4,3,3,9,6,7,19]

根据arr1建立map，值为其优先顺序，设为负值，在自定义排序规则中，若在map中出现过，返回其优先顺序，否则返回其大小，这样就能巧妙实现相对顺序相同。

class Solution {
public:
    vector<int> relativeSortArray(vector<int>& arr1, vector<int>& arr2) {
        unordered_map<int, int> mp;
        for (int i = 0; i < arr2.size(); i++) {
            mp[arr2[i]] = i - 10000;
        }
        sort(arr1.begin(), arr1.end(), [&](int& a, int& b) {
            return (mp.count(a) ? mp[a] : a) < (mp.count(b) ? mp[b] : b);
        });
        return arr1;
    }
};

---

快速排序代码模板 动画

// 对子表进行一趟排序，返回枢轴位置
int partition(vector<int>& arr, int left, int right) {
    int i = left;
    int j = right;
    int key = arr[left];
    // 从左右两端交替向中间扫描
    while (i < j) {
        // 从右向左找第一个小于key的值
        while (i < j && arr[j] >= key) j--;
        swap(arr[i], arr[j]); // 将小于key的值放到左边
        // 从左向右找第一个大于key的值
        while (i < j && arr[i] <= key) i++;
        swap(arr[i], arr[j]); // 将大于key的值放到右边
    }
    return i;
}

// 快速排序
void quickSort(vector<int>& arr, int left, int right) {
    if (left < right) {
        int pivot = partition(arr, left, right);
        quickSort(arr, left, pivot - 1);
        quickSort(arr, pivot + 1, right);
    }
}