C++ 导致向量排序向量出现问题的比较函数[leetcode]

我需要按每个元素向量的第一个元素对向量向量进行排序。这是为了解决Leetcode中的问题。 我为此问题编写了以下代码：

class Solution {
public:
    static bool comparison(const vector<int>& v1, const vector<int>& v2){
        if(v1[0]==v2[0])
            return v1[1]<=v2[1];
        else
            return v1[0]<v2[0];
    }
    
    
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end(), comparison);
        int n = intervals.size();
        
        vector<vector<int>> res;
        if(n >= 1)
            res.push_back(intervals[0]);
        
        for(int i=0;i<n;i++){
            vector<int> rv = res.back();
            vector<int> iv = intervals[i];
            if(rv[1] >= iv[0]){
                res.pop_back();
                res.push_back({min(rv[0], iv[0]), max(iv[1], rv[1])});
            }
            else{
                res.push_back(iv);
            }
        }
        return res;
    }
};

我在比较函数中尝试做的是，如果第一个元素与向量元素相同，我将使用第二个元素进行排序。这段代码给出了一个运行时错误：仅针对一个测试用例，引用绑定到'const int'stl_vector.h类型的空指针。 如果我将比较函数更改为以下内容，则它适用于所有测试用例：

static bool comparison(const vector<int>& v1, const vector<int>& v2){
        return v1[0]<v2[0];
}

谁能解释一下原因吗？

std:：vector:：operator[]不执行绑定检查。由于不检查向量的大小，因此在输入空向量时，比较会导致未定义的行为

通过更改比较的行为，您也可能更改排序的行为，这可能导致传入空向量或不传入空向量。您的运算符已断开。

std:：vector:：operator[]不执行绑定检查。由于不检查向量的大小，因此在输入空向量时，比较会导致未定义的行为

---

通过更改比较的行为，您也可能更改排序的行为，这可能导致传入空向量或不传入空向量。然而，您的运算符已损坏。

比较器需要满足指定的要求，这要求严格的弱排序。您必须满足的一个条件是：

对于所有a，compa，a==假

但例如

comparison({0, 0}, {0, 0});

结果是真的。因为您的比较器不能满足所有的需求，所以您会得到未定义的行为，这在您的案例中表现为崩溃

---

要恢复严格弱排序，替换比较器需要满足命名要求，该要求要求严格弱排序。您必须满足的一个条件是：

对于所有a，compa，a==假

但例如

comparison({0, 0}, {0, 0});

结果是真的。因为您的比较器不能满足所有的需求，所以您会得到未定义的行为，这在您的案例中表现为崩溃

---

要恢复严格的弱排序，请替换我认为我们不需要在std:：sort中进行比较，因为它已经基于间隔的开始进行了排序。如果删除该选项，则您的算法可以正常工作：

struct Solution {
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        int n = intervals.size();

        vector<vector<int>> res;

        if (n >= 1) {
            res.push_back(intervals[0]);
        }

        for (int i = 0; i < n; i++) {
            vector<int> rv = res.back();
            vector<int> iv = intervals[i];

            if (rv[1] >= iv[0]) {
                res.pop_back();
                res.push_back({min(rv[0], iv[0]), max(iv[1], rv[1])});

            } else {
                res.push_back(iv);
            }
        }

        return res;
    }
};

更传统一点：

#include <vector>
#include <algorithm>
#include <cstdint>

struct Solution {
    static std::vector<std::vector<int>> merge( std::vector<std::vector<int>> &intervals) {
        if (intervals.size() < 2) {
            return intervals;
        }

        std::sort(std::begin(intervals), std::end(intervals));

        std::vector<std::vector<int>> merged_intervals;
        merged_intervals.push_back(intervals[0]);

        for (std::size_t index = 1; index < intervals.size(); index++) {
            if (merged_intervals.back()[1] >= intervals[index][0]) {
                merged_intervals.back()[1] = std::max(merged_intervals.back()[1], intervals[index][1]);

            } else {
                merged_intervals.push_back(intervals[index]);
            }
        }

        return merged_intervals;
    }
};

工具书类 有关其他详细信息，请参见。这里有很多公认的解决方案，有各种解释和解释，有高效的算法，还有渐近/复杂性分析。

---

我认为我们不需要在std:：sort中进行比较，因为它已经基于间隔的开始进行了排序。如果删除该选项，则您的算法可以正常工作：

struct Solution {
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        sort(intervals.begin(), intervals.end());
        int n = intervals.size();

        vector<vector<int>> res;

        if (n >= 1) {
            res.push_back(intervals[0]);
        }

        for (int i = 0; i < n; i++) {
            vector<int> rv = res.back();
            vector<int> iv = intervals[i];

            if (rv[1] >= iv[0]) {
                res.pop_back();
                res.push_back({min(rv[0], iv[0]), max(iv[1], rv[1])});

            } else {
                res.push_back(iv);
            }
        }

        return res;
    }
};

更传统一点：

#include <vector>
#include <algorithm>
#include <cstdint>

struct Solution {
    static std::vector<std::vector<int>> merge( std::vector<std::vector<int>> &intervals) {
        if (intervals.size() < 2) {
            return intervals;
        }

        std::sort(std::begin(intervals), std::end(intervals));

        std::vector<std::vector<int>> merged_intervals;
        merged_intervals.push_back(intervals[0]);

        for (std::size_t index = 1; index < intervals.size(); index++) {
            if (merged_intervals.back()[1] >= intervals[index][0]) {
                merged_intervals.back()[1] = std::max(merged_intervals.back()[1], intervals[index][1]);

            } else {
                merged_intervals.push_back(intervals[index]);
            }
        }

        return merged_intervals;
    }
};

工具书类 有关其他详细信息，请参见。这里有很多公认的解决方案，有各种解释和解释，有高效的算法，还有渐近/复杂性分析。

---

传递给比较函数的向量是否有多个元素？您确定传递给比较函数的向量实际上没有任何元素吗？如果读取比较，您会发现该关系必须是。请注意std:：vector:：operator@Someprogrammerdude所有向量都有元素，只有2个元素。传递给比较函数的向量有多个元素单一元素？您确定传递给比较函数的向量实际上没有任何元素吗？如果读取比较，您会发现该关系必须是。请注意std:：vector:：operator@Someprogrammerdude所有向量都有元素，只有两个元素是tanks churill。好奇的是，如果需要一个比较器在比较{a，a}时返回true，我该怎么办？当然，您可以在自己的算法中使用这样的比较器，或者在只比较两个元素时使用这样的比较器。但对于std:：sort，该算法依赖于某些条件才能正常工作。最后，这是由于数学定义的排序应该如何工作，不能改变。谢谢churill。好奇的是，如果需要一个比较器在比较{a，a}时返回true，我该怎么办？当然，您可以在自己的算法中使用这样的比较器，或者在只比较两个元素时使用这样的比较器。但对于std:：sort，该算法依赖于某些条件才能正常工作。最后，这是由于数学定义的排序应该如何工作，不能改变。