java快速排序来合并取值区间

现有5个取值区间

[1,2],[4,6],[3,6],[9,10],[8,17]

将这5个取值区间去掉重复的部分，合并起来为

[1,2],[3,6],[8,17]
 

创建区间类

@Data
public class Interval {

    private Integer left;

    private Integer right;

    public Interval(Integer left, Integer right) {
        if (left <= right) {
            this.left = left;
            this.right = right;
        }

    }
}

将区间放入list，并对区间的left按大小进行快速排序，放在list里

public class QuickSort {
    public static List<Interval> quickSort(List<Interval> input, int start, int end) {
        if (input.size() < 1 || start < 0 || end >= input.size() || start > end) return null;
        int smallindex = partition(input, start, end);
        if (smallindex > start) quickSort(input, start, smallindex - 1);
        if (smallindex < end) quickSort(input, smallindex + 1, end);
        return input;
    }

    private static int partition(List<Interval> input, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(input, pivot, end);
        for (int i = start; i <= end; i++) {
            if (input.get(i).getLeft() <= input.get(end).getLeft()) {
                smallIndex++;
                if (i > smallIndex) swap(input, i, smallIndex);
            }
        }
        return smallIndex;
    }

    public static void swap(List<Interval> input, int i, int j) {
        Interval intervalTemp = input.get(i);
        input.set(i, input.get(j));
        input.set(j, intervalTemp);
    }
}

对已经排好的区间list进行合并

 

public class IntervalOrder {
    public List<Interval> intervalOrder(List<Interval> input) {
        List<Interval> combineInterval = new ArrayList<>();
        for (int i = 0; i < input.size(); i++) {
            if (i == 0) {
                combineInterval.add(input.get(0));
            } else {
                Interval interval = input.get(i);
                if (interval.getRight() >= combineInterval.get(combineInterval.size() - 1).getRight()) {
                    if (interval.getLeft() <= combineInterval.get(combineInterval.size() - 1).getRight()) {
                        combineInterval.get(combineInterval.size() - 1).setRight(interval.getRight());
                    } else {
                        combineInterval.add(input.get(i));
                    }

                }
            }
        }
        return combineInterval;
    }
    
}

 

测试

public static void main(String[] args) {
    Interval interval1 = new Interval(1, 2);
    Interval interval2 = new Interval(4, 6);
    Interval interval3 = new Interval(3, 6);
    Interval interval4 = new Interval(9, 10);
    Interval interval5 = new Interval(8, 17);
    List<Interval> input = new ArrayList<>();
    input.add(interval1);
    input.add(interval2);
    input.add(interval3);
    input.add(interval4);
    input.add(interval5);
    System.out.println(QuickSort.quickSort(input, 0, input.size() - 1));
    IntervalOrder intervalOrder = new IntervalOrder();
    System.out.println(intervalOrder.intervalOrder(QuickSort.quickSort(input, 0, input.size() - 1)));
}

 

输出

[Interval(left=1, right=2), Interval(left=3, right=6), Interval(left=4, right=6), Interval(left=8, right=17), Interval(left=9, right=10)]
[Interval(left=1, right=2), Interval(left=3, right=6), Interval(left=8, right=17)]