Question

我带着一个我想分享的问题来到这里，希望有人能帮助我解决这个问题。我会尝试尽可能清楚地描述问题。问题如下。

我在java中有一个程序，它有一个接收一组日期的方法（java.util.Date）。

| start    end  |
| date1    date1|
<--------------->
|       | start        end  |     |                   |
|       | date2        date2|     |                   |
|       <------------------->     |                   |
|                                 | start        end  |
|                                 | date3        date3|
|                                 <------------------->

在上面的例子中，我们有三个日期，前两个相交，但start-date3在end-date2之后。对于我的商业规则，这是一个时空。

现在考虑下一个场景。

| start    end  |
| date1    date1|
<--------------->
|       | start        end  |     |                   |
|       | date2        date2|     |                   |
|       <------------------->     |                   |
|                                 | start        end  |
|                                 | date3        date3|
|                                 <------------------->   
|  |                                                      |
|  | start                                           end  |
|  | date4                                           date4|
|  <------------------------------------------------------>

在这种情况下，即使在结束日期2和开始日期3之间有一段时间，它也认为它不存在时空，因为它之间的时间start-date4和end-date4涵盖了这样的空间。

我想检索true，如果有一个或多个时间空间，否则我将返回false。

我尝试的唯一方法是循环每个开始/结束关系，比较end-date1 vs start-date2 vs start-date3等等......那不是我想申请的

如果有其他一些想法，欢迎他们。如果您需要更多信息，我会添加它。谢谢。

Answer 1

这个问题有一个非常简单的算法。

创建一个起始值数组和一个单独的结束值数组。
对两个阵列进行排序（独立）。
将 InRange 设置为0.现在按合并顺序扫描两个数组;确保如果值相同，则在起始值之前使用相同的值执行所有结束值。对于扫描中的每个值：

一个。如果它来自结束值数组：递减 InRange 。如果 InRange 现在为0，那么您已经找到了“时间空间”的 start 。

湾如果它来自起始值数组：如果 InRange 为0，则表示您已找到“时间空间”的结束。无论如何，增加 InRange 。

上述算法设计用于半开间隔，其中结束值实际上不包括在间隔中。在日期的情况下，您应该假装开始日期实际上是日期之前的午夜，而结束日期实际上是它之后的午夜（因此它与第二天的开始日期相同）。这会影响按顺序扫描合并数组的方式。如果问题中的日期范围是包含，则只需在每个结束日期添加1即可。

要清楚，在第二个示例中，两个数组将是：

开始日期1，开始日期4，开始日期2，开始日期3
结束日期1，结束日期2，结束日期3，结束日期4

步骤3中的处理顺序为：

开始日期1，开始日期4，开始日期2，结束日期1，开始日期3，结束日期3，结束日期4.

您实际上不必创建两个单独的排序数组。您可以在单个数组中对所有端点（作为端点）进行排序，您可以将每个数据标记为开始或结束。（理想情况下，您需要确保结束X在相同X的起始X之前出现。否则，算法偶尔会产生零长度的“时间空间”范围，您必须忽略它。）

Answer 2

好的，这是一个非常“奇怪”的想法，但看看这个“概念”是否更好。

基本上，我们的想法是将所有重叠日期合并到一些“范围”中，这意味着，在第一个示例中，您将最终得到两个不同的范围（开始日期1到结束日期2和（开始日期3到结束日期3）在你的第二个你最终会得到一个（开始日期1到结束日期4）

所以，如果这个集合只有一个不同的范围，那么你没有差距，其他方面，你做的。

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;

public class TestDateRanges {

    public static void main(String[] args) {
        try {
            List<Date[]> dates = new ArrayList<>(
                    Arrays.asList(
                            new Date[][]{
                                {makeDate("1.1.2015"), makeDate("5.1.2015")},
                                {makeDate("3.1.2015"), makeDate("10.1.2015")},
                                {makeDate("15.1.2015"), makeDate("20.1.2015")},}
                    )
            );

            Collections.sort(dates, new Comparator<Date[]>() {
                @Override
                public int compare(Date[] o1, Date[] o2) {
                    return o1[0].compareTo(o2[0]);
                }
            });

            List<Date[]> ranges = new ArrayList<>(dates.size());
            Date[] baseRange = null;
            for (Date[] range : dates) {
                if (baseRange == null) {
                    baseRange = range;
                    ranges.add(baseRange);
                } else if ((baseRange[0].before(range[0]) || baseRange[0].equals(range[0])) && (baseRange[1].after(range[0]) || baseRange[1].equals(range[0])) {
                    System.out.println("> Overlap " + format(baseRange) + " <-> " + format(range));
                    if (range[1].after(baseRange[1])) {
                        baseRange[1] = range[1];
                    }
                } else {
                    System.out.println("> Out of range " + format(baseRange) + " >-< " + format(range));
                    baseRange = range;
                    ranges.add(baseRange);
                }
            }

            System.out.println("Has " + ranges.size() + " distinct ranges");

            for (Date[] range : ranges) {
                System.out.println(format(range));
            }
        } catch (ParseException exp) {
            exp.printStackTrace();
        }
    }

    public static final DateFormat FORMAT = new SimpleDateFormat("d.M.yyyy");

    protected static final Date makeDate(String value) throws ParseException {
        return FORMAT.parse(value);
    }

    private static String format(Date[] baseRange) {
        return FORMAT.format(baseRange[0]) + "->" + FORMAT.format(baseRange[1]);
    }

    private static Date[] makeDateRange(String from, String to) throws ParseException {
        return new Date[]{makeDate(from), makeDate(to)};
    }

}

哪些输出......

> Overlap 1.1.2015->5.1.2015 <-> 3.1.2015->10.1.2015
> Out of range 1.1.2015->10.1.2015 >-< 15.1.2015->20.1.2015
Has 2 distinct ranges
1.1.2015->10.1.2015
15.1.2015->20.1.2015

现在，如果我将设置更改为...

List<Date[]> dates = new ArrayList<>(
        Arrays.asList(
                new Date[][]{
                    {makeDate("1.1.2015"), makeDate("5.1.2015")},
                    {makeDate("3.1.2015"), makeDate("10.1.2015")},
                    {makeDate("15.1.2015"), makeDate("20.1.2015")},
                    makeDateRange("2.1.2015", "25.1.2015")
                }
        )
);

它输出......

> Overlap 1.1.2015->5.1.2015 <-> 2.1.2015->25.1.2015
> Overlap 1.1.2015->25.1.2015 <-> 3.1.2015->10.1.2015
> Overlap 1.1.2015->25.1.2015 <-> 15.1.2015->20.1.2015
Has 1 distinct ranges
1.1.2015->25.1.2015

这只是一个概念性的想法，您应该注意，此示例将更改dates列表中的数据，因此您需要确保首先获得数据的副本

在一组日期中查找时间空间

2 个答案: