56. Merge Intervals 好代码

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

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

lamda 表达式简介：

ISO C++ 11 标准的一大亮点是引入Lambda表达式。基本语法如下：

[capture list] (parameter list) ->return type { function body } [1]  

其中除了“[ ]”（其中捕获列表可以为空）和“复合语句”（相当于具名函数定义的函数体），其它都是可选的。它的类型是唯一的具有成员operator()的非联合的类类型，称为闭包类型(closure type)。

C++中，一个lambda表达式表示一个可调用的代码单元。我们可以将其理解为一个未命名的内联函数。它与普通函数不同的是，lambda必须使用尾置返回来指定返回类型。

例如调用<algorithm>中的std::sort，ISO C++ 98 的写法是要先写一个compare函数：

1 2 3 4

bool  compare( int &a, int &b) { return  a>b; //降序排序 }

然后，再这样调用：

1	sort(a,a+n,compare);

然而，用ISO C++ 11 标准新增的Lambda表达式，可以这么写：

1	sort(a,a+n,[]( int  a, int  b){ return  a>b;}); //降序排序

这样一来，代码明显简洁多了。

由于Lambda的类型是唯一的，不能通过类型名来显式声明对应的对象，但可以利用auto关键字和类型推导：

1	auto  f=[]( int  a, int  b){ return  a>b;};

和其它语言的一个较明显的区别是Lambda和C++的类型系统结合使用，如：

1 2 3 4

auto  f=[x]( int  a, int  b){ return  a>x;}); //x被捕获复制 int  x=0,y=1; auto  g=[&]( int  x){ return  ++y;}); //y被捕获引用，调用g后会修改y，需要注意y的生存期 bool (*fp)( int , int )=[]( int  a, int  b){ return  a>b;}); //不捕获时才可转换为函数指针

Lambda表达式可以嵌套使用。

即将出版的ISO C++14支持基于类型推断的泛型lambda表达式。上面的排序代码可以这样写：

1	sort(a,a+n,[]( const  auto &a, const  auto &b){ return  a>b;}); //降序排序：不依赖a和b的具体类型

因为参数类型和函数模板参数一样可以被推导而无需和具体参数类型耦合，有利于重构代码；和使用auto声明变量的作用类似，它也允许避免书写过于复杂的参数类型。特别地，不需要显式指出参数类型使使用 高阶函数变得更加容易。