[leetcode-排序]56. 合并区间

给出一个区间的集合，请合并所有重叠的区间。

示例 1:

输入: [[1,3],[2,6],[8,10],[15,18]]
输出: [[1,6],[8,10],[15,18]]
解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2:

输入: [[1,4],[4,5]]
输出: [[1,5]]
解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。

//==============================快速排序=====================================

/**
* Definition for an interval.
* struct Interval {
* int start;
* int end;
* };
*/
/**
* Return an array of size *returnSize.
* Note: The returned array must be malloced, assume caller calls free().
*/

//快速排序
int partition(struct Interval *nums, int l, int r)
{
int low=l, high=r;
int sentry_start = nums[low].start;
int sentry_end = nums[low].end;

while(low<high)
{
while(low<high && nums[high].start>=sentry_start)
{
high--;
}
nums[low].start=nums[high].start;
nums[low].end=nums[high].end;

while(low<high && nums[low].start<=sentry_start)
{
low++;
}
nums[high].start=nums[low].start;
nums[high].end=nums[low].end;
}
nums[low].start=sentry_start;
nums[low].end=sentry_end;

return low;
}

void quickSort(struct Interval *nums, int l, int r){
while(l < r)
{
int mid=partition(nums, l, r);
quickSort(nums, l, mid-1);
//quickSort(nums, mid+1, r);
l=mid+1;
}
}
struct Interval* merge(struct Interval* intervals, int intervalsSize, int* returnSize) {
if(intervals==NULL || intervalsSize<1)
{
return NULL;
}

//先按start进行从小到大排序
quickSort(intervals, 0, intervalsSize-1);

//设置临时数组，存放合并结果
struct Interval list[intervalsSize];

int i;
int index=0;
int m_start=0, m_end=0;

//遍历原始元素序列
for(i=0; i<intervalsSize; ++i)
{
//变量存储两个初始值，用于比较
m_start = intervals[i].start;
m_end = intervals[i].end;

// 遍历后续元素序列，查找与其重合的元素
// 查找规则：
// 1. 因为已经按start排序，只比较当前元素的end值，即当后面元素的start小于等于当前元素的end，则说明重合。
// 2. 此处索引最大为倒数第二个，因为需要与倒数第一个元素进行比较
while(i<intervalsSize-1 && intervals[i+1].start<=m_end)
{
m_end = m_end >= intervals[i+1].end ? m_end : intervals[i+1].end; //两者取大的end，start当前元素已经最小

//索引前进，继续遍历
// 1.intervals[i+1].start<=m_end 结束遍历时，后续还有元素需要遍历
// 2. i<intervalsSize-1 结束遍历时，最后比较的是倒数第二个元素与最后一个元素，结束时 i=intervalsSize-1 即最后一个元素的索引
i++;
}

//遍历的结果存放到临时结果数组
list[index].start = m_start;
list[index].end = m_end;

//更新临时结果数组的索引
index++;
}

//分配最后返回的结果集
struct Interval* res = (struct Interval*)calloc(index, sizeof(struct Interval));

//把临时结果集的数据转移到最后返回的结果集，其个数为index
for(i=0; i<index; ++i)
{
res[i].start=list[i].start;
res[i].end=list[i].end;
}

*returnSize=index;
return res;
}

[leetcode-排序]56. 合并区间

猜你喜欢