java实现knn算法

KNN是一种机器学习算法，主要用于分类和回归。它的工作原理是将每个数据点分配到它最接近的k个邻居之一，然后利用这些邻居的标签来预测新数据点的标签。

以下是使用Java实现KNN算法的示例代码：

import java.util.*;

public class KNN {
    // 使用欧几里得距离计算两个数据点之间的距离
    public static double euclideanDistance(double[] x, double[] y) {
        double distance = 0;
        for (int i = 0; i < x.length; ++i) {
            distance += Math.pow(x[i] - y[i], 2);
        }
        return Math.sqrt(distance);
    }

    // 在给定的训练集中查找k个最近邻居
    public static int[] nearestNeighbors(double[] x, double[][] data, int k) {
        double[] distances = new double[data.length];

        // 计算x和数据集中每个点的距离
        for (int i = 0; i < data.length; ++i) {
            distances[i] = euclideanDistance(x, data[i]);
        }

        // 找到k个最近邻居的索引
        int[] neighbors = new int[k];
        for (int i = 0; i < k; ++i) {
            int index = 0;
            double min = distances[0];
            for (int j = 1; j < distances.length; ++j) {
                if (distances[j] < min) {
                    index = j;
                    min = distances[j];
                }
            }
            neighbors[i] = index;
            distances[index] = Double.MAX_VALUE;
        }

        return neighbors;
    }

    // 对x进行分类
    public static String classify(double[] x, double[][] data, String[] labels, int k) {
        // 找到k个最近邻居的索引
        int[] neighbors = nearestNeighbors(x, data, k);

        // 统计每个类的数量
        Map<String, Integer> counts = new HashMap<>();
        for (int i = 0; i < neighbors.length; ++i) {
            String label = labels[neighbors[i]];
            counts.put(label, counts.getOrDefault(label, 0) + 1);
        }

        // 找到数量最多的类
        String result = null;
        int maxCount = -1;
        for (String label : counts.keySet()) {
            int count = counts.get(label);
            if (count > maxCount) {
                result = label;
                maxCount = count;
            }
        }

        return result;
    }

    public static void main(String[] args) {
        double[][] data = new double[][]{{1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}};
        String[] labels = new String[]{"A", "A", "B", "B", "B"};
        double[] x = new double[]{2.5, 2.5};

        int k = 3;
        String result = classify(x, data, labels, k);
        System.out.println("分类结果：" + result);
    }
}

在这个示例中，我们使用欧几里得距离作为两个数据点之间的距离度量，然后使用nearestNeighbors方法找到最近的k个邻居，最后使用classify方法对新数据点进行分类。