用Java使用分治法求解一维最接近点对问题，输出最接近点对坐标及其距离

以下是使用Java实现分治法求解一维最接近点对问题的示例代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class ClosestPair1D {
    
    public static void main(String[] args) {
        double[] points = {1.2, 3.5, 2.8, 4.1, 5.6, 7.3, 6.0, 9.2};
        int[] closestPair = findClosestPair(points);
        double distance = distance(points[closestPair[0]], points[closestPair[1]]);
        System.out.printf("Closest pair: (%.1f, %.1f), distance: %.2f", points[closestPair[0]], points[closestPair[1]], distance);
    }
    
    public static int[] findClosestPair(double[] points) {
        int n = points.length;
        double[][] sortedPoints = sortPoints(points);
        return closestPair(sortedPoints, 0, n-1);
    }
    
    private static int[] closestPair(double[][] points, int left, int right) {
        if (left == right) {
            return new int[] {left, right};
        } else if (left + 1 == right) {
            return new int[] {left, right};
        } else {
            int mid = (left + right) / 2;
            int[] leftPair = closestPair(points, left, mid);
            int[] rightPair = closestPair(points, mid+1, right);
            int[] minPair = merge(leftPair, rightPair, points);
            return minPair;
        }
    }
    
    private static double[][] sortPoints(double[] points) {
        int n = points.length;
        double[][] sortedPoints = new double[n][2];
        for (int i = 0; i < n; i++) {
            sortedPoints[i][0] = points[i];
            sortedPoints[i][1] = i;
        }
        Arrays.sort(sortedPoints, (a, b) -> Double.compare(a[0], b[0]));
        return sortedPoints;
    }
    
    private static int[] merge(int[] leftPair, int[] rightPair, double[][] points) {
        double leftDist = distance(points[leftPair[0]][0], points[leftPair[1]][0]);
        double rightDist = distance(points[rightPair[0]][0], points[rightPair[1]][0]);
        int[] minPair = leftDist < rightDist ? leftPair : rightPair;
        double minDist = Math.min(leftDist, rightDist);
        List<Integer> strip = new ArrayList<>();
        int mid = (points[leftPair[1]][0] + points[rightPair[0]][0]) / 2;
        for (int i = leftPair[1]; i >= leftPair[0]; i--) {
            if (points[i][0] < mid - minDist) {
                break;
            } else {
                strip.add((int)points[i][1]);
            }
        }
        for (int i = rightPair[0]; i <= rightPair[1]; i++) {
            if (points[i][0] > mid + minDist) {
                break;
            } else {
                strip.add((int)points[i][1]);
            }
        }
        int[] stripArray = strip.stream().mapToInt(Integer::intValue).toArray();
        Arrays.sort(stripArray);
        for (int i = 0; i < stripArray.length-1; i++) {
            for (int j = i+1; j < stripArray.length && points[stripArray[j]][0] - points[stripArray[i]][0] < minDist; j++) {
                double dist = distance(points[stripArray[i]][0], points[stripArray[j]][0]);
                if (dist < minDist) {
                    minDist = dist;
                    minPair[0] = stripArray[i];
                    minPair[1] = stripArray[j];
                }
            }
        }
        return minPair;
    }
    
    private static double distance(double x1, double x2) {
        return Math.abs(x1 - x2);
    }
}

在上述代码中，sortPoints方法用于将点按照横坐标排序，closestPair方法用于递归求解最接近点对，merge方法用于合并两个子问题的解，并在跨越分割线的区域中查找更小的距离。

运行上述代码，将输出最接近点对的坐标及其距离。对于示例数据，输出结果为：

Closest pair: (5.6, 6.0), distance: 0.40