很抱歉冗长，但我相信这个问题值得 :-) 。这个解在区间数上是 n*log(n)。这种复杂性发生的位置在区间的排序范围内。请注意，此解决方案注意包括一个区间完全包含在另一个区间内的情况。结果组的子区间是反向排序的，但如果您愿意，可以通过在末尾反转列表来轻松解决此问题。我不建议通过在开头而不是结尾插入连接间隔来修复它，因为如果您使用基于 ArrayList 的实现，这会将复杂性增加到 O(n^2)。我想您可能可以使用 LinkedList 并在开头插入，但这可能会在其他地方对您造成伤害，具体取决于您在形成这些组后如何处理它们。
public static long max(long a, long b){
return (a>b ? a : b);
}
public static long min(long a, long b){
return (a<b ? a : b);
}
/**
* A meta interval is composed of sub intervals. Its left endpoint is
* the leftmost point of its subintervals and its right endpoint is
* the rightmost point of its subintervals.
*/
static class MetaInterval extends Interval{
/**
* meta intervals are composed of lists of subintervals.
*/
private List<Interval> subintervals;
public MetaInterval(Interval initialSubInterval){
super(initialSubInterval.getLeft(),initialSubInterval.getRight(),null);
this.subintervals = new ArrayList<Interval>();
this.subintervals.add(initialSubInterval);
}
public void join(MetaInterval other){
verifyOverlap(other);
this.setLeft(min(this.getLeft(),other.getLeft()));
this.setRight(max(this.getRight(),other.getRight()));
this.subintervals.addAll(other.getSubintervals());
other.invalidate();
}
public void setSubintervals(List<Interval> subintervals){
this.subintervals = subintervals;
}
public List<Interval> getSubintervals(){
return this.subintervals;
}
private void invalidate(){
this.setSubintervals(null);
this.setLeft(0);
this.setRight(0);
}
public boolean isInvalid(){
return this.getSubintervals()==null;
}
}
//maintaining epoch time
static class Interval implements Comparable<Interval>{
private long left;
private long right;
private String intervalId;
public Interval(long left, long right, String intervalId){
this.left = left;
this.right = right;
this.intervalId = intervalId;
}
public boolean pointIsIn(long point){
return (point>=this.getLeft() && point<=this.getRight());
}
public long getLeft(){
return left;
}
public long getRight(){
return right;
}
public void setLeft(long left){
this.left = left;
}
public void setRight(long right){
this.right = right;
}
public String getIntervalId(){
return intervalId;
}
public boolean overlaps(Interval other){
return pointIsIn(other.getLeft()) || pointIsIn(other.getRight()) || other.pointIsIn(getLeft()) || other.pointIsIn(getRight());
}
public void verifyOverlap(Interval other){
if(!overlaps(other)){
throw new IllegalStateException("Other interval does not overlap");
}
}
/**
* Sort by leftmost part of interval.
*/
@Override
public int compareTo(Interval o) {
return Long.compare(this.getLeft(), o.getLeft());
}
public String toString(){
return intervalId+":["+getLeft()+","+getRight()+"]";
}
}
/**
* Given a list of intervals, returns a list of interval groups where
* the intervals in the groups all overlap. So if A overlaps with B and
* B with C, then A,B,and C will be returned in a group. Supposing intervals
* D and E share nothing with A, B, or C, but do share with each other, D and E
* will be returned as a separate group from A,B,C.
* @param baseIntervals
* @return
*/
public static List<List<Interval>> getOverlappingGroups(List<Interval> baseIntervals){
List<MetaInterval> baseMetaIntervals = toMetaIntervals(baseIntervals);
List<MetaInterval> mergedMetaIntervals = getMergedMetaIntervals(baseMetaIntervals);
List<List<Interval>> intervalGroups = metaIntervalsToGroups(mergedMetaIntervals);
return intervalGroups;
}
private static List<MetaInterval> getMergedMetaIntervals(
List<MetaInterval> metaIntervals) {
if(metaIntervals.isEmpty()){
return metaIntervals;
}
//order the meta intervals by their starting point.
Collections.sort(metaIntervals);
//go through and merge the overlapping meta intervals.
//This relies on the logic that if interval i overlaps with
//an interval that started before it, then once all the intervals
//before i have been merged, interval i will have a starting point
//consecutive to the starting point of the the preceeding interval.
for(int i=0; i< metaIntervals.size()-1; i++){
MetaInterval thisInterval = metaIntervals.get(i);
MetaInterval nextInterval = metaIntervals.get(i+1);
if(thisInterval.overlaps(nextInterval)){
nextInterval.join(thisInterval);
}
}
List<MetaInterval> resultIntervals = new ArrayList<MetaInterval>();
//All intervals from the original list either:
//(a) didn't overlap with any others
//(b) overlapped with others and were chosen to represent the merged group or
//(c) overlapped with others, were represented in the group in another meta
// interval, and then marked as invalid.
//Go through and only add the valid intervals to be returned.
for(MetaInterval i : metaIntervals){
if(!i.isInvalid()){
resultIntervals.add(i);
}
}
return resultIntervals;
}
/**
* Convert a list of meta intervals into groups of intervals.
* @param mergedMetaIntervals
* @return
*/
private static List<List<Interval>> metaIntervalsToGroups(
List<MetaInterval> mergedMetaIntervals) {
List<List<Interval>> groups = new ArrayList<>(mergedMetaIntervals.size());
for(MetaInterval metaInterval : mergedMetaIntervals){
groups.add(metaInterval.getSubintervals());
}
return groups;
}
private static List<MetaInterval> toMetaIntervals(
List<Interval> baseIntervals) {
ArrayList<MetaInterval> metaIntervals = new ArrayList<MetaInterval>(baseIntervals.size());
for(Interval i : baseIntervals){
metaIntervals.add(new MetaInterval(i));
}
return metaIntervals;
}
public static void main(String[] args){
Interval a = new Interval(20, 30, "A");
Interval b = new Interval(21,22,"B");
Interval c = new Interval(500,503,"C");
Interval d = new Interval(28,38, "D");
Interval e = new Interval(490,502,"E");
//note: A,B, and D are an overlapping group, and
//D and E are another.
List<List<Interval>> intervalGroups = getOverlappingGroups(Arrays.asList(a,b,c,d,e));
for(List<Interval> group : intervalGroups){
System.out.println(group.toString());
}
}
输出：
[D:[28,38], B:[21,22], A:[20,30]]
[C:[500,503], E:[490,502]]