leetcode练习题目

这样一道题目花费了不少时间看来真的是编程新手。

struct Interval {
      int start;
      int end;
      Interval() : start(0), end(0) {}
      Interval(int s, int e) : start(s), end(e) {}
  };
class Solution {
public:
     vector merge(vector& intervals){
         while(mergeone(intervals))
         {

         }  
         return intervals;
     }

     bool mergeone(vector& intervals){
        vector intervals2;
        bool a = false;
        for(int i = 0; i < intervals.size();++i)
        {
            if(0 ==i)
            {
                intervals2.push_back(intervals[i]);
                continue;
            }
            else
            {
                Interval up = intervals2[intervals2.size()-1];
                Interval down = intervals[i];

                if(up.end < down.start || up.start > down.end)
                {
                    intervals2.push_back(down);
                    continue;
                }
                else if(up.start == down.start && up.end == down.end)
                {
                    continue;
                }
                else{
                    int we = min(up.start,down.start);
                    int ma = max(up.end,down.end);
                    Interval temp(we,ma);
                    intervals2.pop_back();
                    intervals2.push_back(temp);
                    a = true;
                }
            }
        }
        intervals = intervals2;
        return a;
     }

};

用一个新的vector，然后一个一个和新的vector最后一个元素合并，合并的时候其实还是需要注意技巧的，详细见代码。
这样的代码还是在leetcode的引导之下进行的，其中进行了多次的合并，因为依据我的算法合并一次后还存在合并的潜能比如
【1，2】【3，4】【5，6】【8，9】，【1，10】
mergeone之后为
【1，2】【3，4】【5，6】，【1，10】
由此看到并没有合并彻底，因此需要进行多次的合并，所以在merge主函数merge中用了while语句，这样leetcode给出了time exceed的警告，确实程序的效率并不是很好。要进一步的优化。
费时间的原因在于没有提前排序，如果排序之后应该就快很多

# Definition for an interval.
# class Interval:
#     def __init__(self, s=0, e=0):
#         self.start = s
#         self.end = e

class Solution:
    # @param {Interval[]} intervals
    # @return {Interval[]}
    def merge(self, intervals):
     if not intervals:
            return []
     else:
        intervals.sort(key=lambda x: x.start)
        result = [intervals[0]]
        for i in range(1,len(intervals)):
            if result[-1].end >= intervals[i].start:
                result[-1].end = max(intervals[i].end,result[-1].end )
            else:
                result.append(intervals[i])
        return result

别人的python代码，确实很简单几句话就写完了，关键在与对列表排序是代码真的很简洁，思想挺不错的挺好的。
c++中也有简洁的排序代码

/**
 * 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:
    static bool comp(const Interval& a, const Interval& b){
    return a.start < b.start;
}

vector merge(vector &intervals) {
    vector intervals2;
    if(intervals.size()<=1){
        return intervals;
    }
    else
    {
        sort(intervals.begin(), intervals.end(), comp);
        intervals2.push_back(intervals[0]);
        for(int i = 1; i < intervals.size();++i){

                    Interval up = intervals2[intervals2.size()-1];
                    Interval down = intervals[i];

                    if(up.end >= down.start)
                    {
                        int ma = max(up.end,down.end);
                        intervals2[intervals2.size()-1].end = ma;
                    }
                    else{

                        intervals2.push_back(down);
                    }
            }
            return intervals2;
    }
}

};

虽然这次进步很多，但是cpp程序运行效率还是很好的只不过自己写的很差劲而已