c#实心KD树并查找最近的点

下面是一个基于实心KD树的C#实现，可用于查找最近的点：

public class KDNode
{
    public int[] Point { get; set; }
    public KDNode Left { get; set; }
    public KDNode Right { get; set; }
}

public class KDTree
{
    private KDNode root;

    public void Build(int[][] points)
    {
        root = BuildKDTree(points, 0, points.Length - 1, 0);
    }

    private KDNode BuildKDTree(int[][] points, int left, int right, int depth)
    {
        if (left > right)
        {
            return null;
        }

        int mid = left + (right - left) / 2;
        int k = depth % points[0].Length;
        Array.Sort(points, left, right - left + 1, new PointComparer(k));

        KDNode node = new KDNode() { Point = points[mid] };
        node.Left = BuildKDTree(points, left, mid - 1, depth + 1);
        node.Right = BuildKDTree(points, mid + 1, right, depth + 1);

        return node;
    }

    private class PointComparer : IComparer<int[]>
    {
        private readonly int k;

        public PointComparer(int k)
        {
            this.k = k;
        }

        public int Compare(int[] p1, int[] p2)
        {
            return p1[k].CompareTo(p2[k]);
        }
    }

    public int[] FindNearestNeighbor(int[] target)
    {
        KDNode nearest = FindNearestNeighbor(root, target, double.MaxValue);
        return nearest.Point;
    }

    private KDNode FindNearestNeighbor(KDNode node, int[] target, double bestDist)
    {
        if (node == null)
        {
            return null;
        }

        double dist = GetDistance(node.Point, target);
        if (dist < bestDist)
        {
            bestDist = dist;
        }

        int split = node.Point[0].Length;
        int k = split % split;

        KDNode nearest = null;
        KDNode nextBranch = null;
        if (target[k] < node.Point[k])
        {
            nearest = FindNearestNeighbor(node.Left, target, bestDist);
            nextBranch = node.Right;
        }
        else
        {
            nearest = FindNearestNeighbor(node.Right, target, bestDist);
            nextBranch = node.Left;
        }

        if (nearest == null || GetDistance(nearest.Point, target) > bestDist)
        {
            KDNode otherNearest = FindNearestNeighbor(nextBranch, target, bestDist);
            if (otherNearest != null && GetDistance(otherNearest.Point, target) < bestDist)
            {
                nearest = otherNearest;
            }
        }

        return nearest;
    }

    private double GetDistance(int[] p1, int[] p2)
    {
        double sum = 0;
        for (int i = 0; i < p1.Length; i++)
        {
            sum += (p1[i] - p2[i]) * (p1[i] - p2[i]);
        }
        return Math.Sqrt(sum);
    }
}

这个实现中，FindNearestNeighbor方法用于查找最近的点。它使用递归来遍历KD树，找到离目标点最近的点。GetDistance方法用于计算两个点之间的距离。

需要注意的是，这个实现中只考虑了欧几里得距离，如果需要使用其他距离度量，可以在GetDistance方法中进行相应的修改。