LeetCode-热题100-笔记-day10

56. 合并区间https://leetcode.cn/problems/merge-intervals/

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

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

官方解析

class Solution {
    public int[][] merge(int[][] intervals) {
        if(intervals.length==0){
            return new int[0][2];
        }
        //排序
        Arrays.sort(intervals, new Comparator<int[]>(){
            public int compare(int[] O1, int[] O2){
                return O1[0]-O2[0];
            }
        });

        List<int[]> merged=new ArrayList<>();
        //遍历
        for(int i=0;i<intervals.length;++i){
            //根据L和R判断
            int L=intervals[i][0], R=intervals[i][1];
            //不合并：当merged为空或它的最后一个区间的右侧边界小于intervals元素的左侧边界加入答案中
            if(merged.size()==0||merged.get(merged.size()-1)[1]<L){
                merged.add(new int[]{L,R});
            }else{
                //合并：若merged中的最后一个元素右侧边界小于即将加入的元素做的边界，则产生合并，取较大者作为新的最后一个元素右侧边界（简单来说该算法只修改最后一个元素的右侧边界）
                merged.get(merged.size() - 1)[1] = Math.max(merged.get(merged.size() - 1)[1], R);
            }
        }

        return merged.toArray(new int[merged.size()][]);
    }
}

Java知识复习

Arrays.sort()

当你使用Arrays.sort()方法对数组进行排序时，如果数组中的元素是基本数据类型（如int、double等），它会使用快速排序（QuickSort）算法进行排序。如果数组中的元素是对象类型，它会默认调用对象的compareTo()方法进行排序，或者你可以传递一个Comparator对象来指定自定义的排序规则。

下面是一些示例，展示如何使用Arrays.sort()来对数组进行排序：

对基本数据类型数组排序：

int[] numbers = {5, 2, 8, 1, 9, 3};
Arrays.sort(numbers);

for (int num : numbers) {
    System.out.print(num + " ");
}

 对对象数组排序（使用默认排序规则）：

class Person implements Comparable<Person> {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person otherPerson) {
        return this.age - otherPerson.age;
    }
}

Person[] people = {
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 22)
};

Arrays.sort(people);

for (Person person : people) {
    System.out.println(person.name + " - " + person.age);
}

对对象数组排序（使用自定义排序规则，通过Comparator）：

import java.util.Arrays;
import java.util.Comparator;

class NameLengthComparator implements Comparator<Person> {
    @Override
    public int compare(Person person1, Person person2) {
        return person1.name.length() - person2.name.length();
    }
}

Person[] people = {
    new Person("Alice", 25),
    new Person("Bob", 30),
    new Person("Charlie", 22)
};

Arrays.sort(people, new NameLengthComparator());

for (Person person : people) {
    System.out.println(person.name + " - " + person.age);
}

Arrays.sort() 方法使用 compare() 方法对数组进行排序时，排序的顺序取决于 compare() 方法的返回值。具体来说，排序是基于以下几个情况：

1. 如果 compare() 方法返回负整数：表示第一个元素应该在第二个元素之前。这意味着第一个元素比第二个元素更小。

2. 如果 compare() 方法返回零：表示两个元素相等，它们的相对顺序不会被改变。

3. 如果 compare() 方法返回正整数：表示第一个元素应该在第二个元素之后。这意味着第一个元素比第二个元素更大。

排序算法会根据 compare() 方法的返回值来决定元素的最终排列顺序。如果你想要升序排序，通常在 compare() 方法中返回负整数、零或正整数，以便根据你的比较逻辑来定义元素的相对顺序。

测试 

package LeetCode;

import com.alibaba.druid.support.json.JSONUtils;

import java.util.Arrays;
import java.util.Comparator;

/**
 * @time: 2023/8/27 21:22
 */
public class TestComparator {

    public static class Person{
        public String name;
        public int age;

        public Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
    }
    public static void main(String[] args) {
        Person[] people = {
                new Person("Alice", 25),
                new Person("Bob", 30),
                new Person("Charlie", 22)
        };

        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.name.length()- o2.name.length();
            }
        });
        for (Person person : people) {
            System.out.println(person.name + " - " + person.age);
        }
        System.out.println("以上使用名字长度排序===以下使用年龄排序");
        Arrays.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.age- o2.age;
            }
        });
        for (Person person : people) {
            System.out.println(person.name + " - " + person.age);
        }
    }
}

测试结果