java

java记

1、Arrays.sort(points, (a, b) -> a[1] > b[1] ? 1 : -1);
points里面为[[1,2],[2,3]]的格式
(a,b)则指的是[1,2]和[2,3]
a[1]=2,a[0]=1
所以经过排序变为，按照右边界从小到大排序。
涉及到的是452

当使用sort(Objetc[] a)来进行对象的自然排序，该对象必需实现Compareable接口，重写compareableTo方法，并一般在此方法中定义这3种返回值（1，0，-1）来进行排序标准的确认。

return 1 时，按照从小到大排序 return 0 时，原位置不动 return-1 时，按照从在到小排序 而让对象继成Compareable接口的方式，称为内部比较器。

注意，返回值常规用1，0，-1，并不是说一定要用1或者-1.此处的1和-1只代表俩值相减后为正数还是负数，那么，如果这样理解，我们同样也可以反回 2，0，-2

2. 归并排序
   package com.learn.algo;

import java.util.Arrays;

public class Sort {
public static void main(String[] args) {
int[] numbers = new int[] {1,2,3,1,2,5,14,21,11,20,95,100,8,9};
System.out.println(Arrays.toString(numbers));
mergeSort(numbers,0,numbers.length - 1);
System.out.println(Arrays.toString(numbers));
}

/**
 * 归并排序
 * @param numbers 待排序数组
 * @param startIndex
 * @param endIndex
 */
public static void mergeSort(int[] numbers, int startIndex, int endIndex) {
    //递归出口
    if (startIndex >= endIndex) return;
    //计算数组的中间元素下标
    int middleIndex = (endIndex + startIndex) / 2;
    //对左边进行排序
    mergeSort(numbers, startIndex, middleIndex);
    //对右边进行排序
    mergeSort(numbers, middleIndex + 1, endIndex);
    //合并左右有序数组
    merge(numbers, startIndex, middleIndex, endIndex);
}

/**
 * 合并两个有序数组
 * @param numbers
 * @param startIndex
 * @param middleIndex
 * @param endIndex
 */
private static void merge(int numbers[], int startIndex, int middleIndex, int endIndex) {
    //定义一个缓存数组
    int[] buffer = new int[endIndex - startIndex + 1];

    //从左边开始比较，左边的小于等于右边的就排在前面，这样原有数组中元素大小的相对位置不会改变，该算法就为稳定的排序算法
    //左边有序数组number[startIndex]->number[middleIndex]
    //右边有序数组number[middleIndex + 1]->number[endIndex]
    //while中的条件是为了保证左边或右边的有序数组至少有一个遍历完
    int l = startIndex, r = middleIndex + 1, i = 0;
    while (l <= middleIndex && r <= endIndex) {
        if (numbers[l] <= numbers[r]) {
            buffer[i++] = numbers[l++];
        } else {
            buffer[i++] = numbers[r++];
        }
    }
    //如果左边的有序数组未遍历完则直接提取出左边的元素
    while (l <= middleIndex) {
        buffer[i++] = numbers[l++];
    }

    //如果右边的有序数组未遍历完则直接提取出左边的元素
    while (r <= endIndex) {
        buffer[i++] = numbers[r++];
    }

    //赋值给原始数组
    System.arraycopy(buffer, 0, numbers, startIndex, buffer.length);
}

}
代码转载自https://blog.csdn.net/qq_31766141/article/details/107141439