leetcode 56. 合并区间【不能在c++类中定义cmp】

方法一：O（nlogn）

sort 函数的功能很易于扩展，我们可以给它一个比较函数，让它按我们希望的方式工作。

    如果想要自定义比较函数，就像这样：

    bool less_int(int a,int b){

        return b

    }

执行用时 : 32 ms, 在Merge Intervals的C++提交中击败了62.40% 的用户

内存消耗 : 13.2 MB, 在Merge Intervals的C++提交中击败了5.08% 的用户

 万万没想到啊，c++的类成员函数不能做sort的比较函数！！！！！

只能用lamba表达式了：

 sort(tmp.begin(),tmp.end(),[](zb a,zb b){if(a.x==b.x)return a.left

主要意思就是用结构体储存区间的起始和结束位置，起始置为1，结束置为2，然后统一排序，根据起始和结束的数量是否匹配来判定重合。 

class Solution {
public:
    struct zb{
      int x;
      int left;//左边：1 右边：2
      zb(int a,int b)
      {
          x=a;left=b;
      }
    };
    vector > merge(vector >& intervals) {
        //坐标打表

        vector tmp;
        vector > ans;
        vector res;
        for(int i=0;i

 

方法二： 直接将原来的数组按左端排序，如果子元组的右端大于右边子元组的左端，那么合并，直到不满足的时候创建新的元组。

但是不知道为什么这种方法很慢。

执行用时 : 204 ms, 在Merge Intervals的C++提交中击败了10.32% 的用户

内存消耗 : 27.3 MB, 在Merge Intervals的C++提交中击败了5.08% 的用户

class Solution {
public:

    vector > merge(vector >& intervals) {
        vector >ans;
        if(intervals.size()==0) return ans;
        sort(intervals.begin(),intervals.end(),[](vector a,vector b){if(a[0]==b[0]) return a[1]>b[1];return a[0]=intervals[i][0]) 
            {
                if(r tmp(2);
                //tmp.push_back(l);
                // tmp.push_back(r);
                tmp[0]=l;tmp[1]=r;
                ans.push_back(tmp);
                l=intervals[i][0];
                r=intervals[i][1];
            }
        }
                vector tmp(2);
                //tmp.push_back(l);
                // tmp.push_back(r);
                tmp[0]=l;tmp[1]=r;
        ans.push_back(tmp);
        return ans;
        
    }
};

参考方法！；

这个方法不需要定义中间数组，直接在原数组上操作，方便和块了很多（无法运行，只是传授概念）

class Solution {
public:
    vector merge(vector& intervals) {
        if (intervals.empty()) return {};
        sort(intervals.begin(), intervals.end(), [](Interval &a, Interval &b) {return a.start < b.start;});
        vector res{intervals[0]};
        for (int i = 1; i < intervals.size(); ++i) {
            if (res.back().end < intervals[i].start) {
                res.push_back(intervals[i]);
            } else {
                res.back().end = max(res.back().end, intervals[i].end);
            }
        }   
        return res;
    }
};