Java 在新2D数组中排序2D数组（K-均值聚类）

作为输入，我有一个2D数组

PointXY[][]簇

，如下所示：

[[23.237633,53.78671], [69.15293,17.138134], [23.558687,45.70517]] . . .
[[47.851738,16.525734], [47.802097,16.689285], [47.946404,16.732542]]
[[47.89601,16.638218], [47.833263,16.478987], [47.88203,16.45793]]
[[47.75438,16.549816], [47.915512,16.506475], [47.768547,16.67624]]
.
.
.

因此数组中的元素的类型为

PointXY[]

定义如下：

[[23.237633,53.78671], [69.15293,17.138134], [23.558687,45.70517]] . . .
[[47.851738,16.525734], [47.802097,16.689285], [47.946404,16.732542]]
[[47.89601,16.638218], [47.833263,16.478987], [47.88203,16.45793]]
[[47.75438,16.549816], [47.915512,16.506475], [47.768547,16.67624]]
.
.
.

public PointXY（浮点x，浮点y）{
这个.x=x；
这个。y=y；
}

我想做的是对输入集群进行排序，并将排序后的数据写入数组

PointXY[]]clustersorted

，这样集群中的每个

PointXY

（第一行除外）都会与第一行的每个值进行比较。 换言之，下面图片中蓝色集合中的元素将与红色圆圈中的每个值进行比较。 所以我想比较2的每个值。行向前移动到第一行中的每个值

比较是通过调用欧几里德函数来完成的

公共双欧几里得（PointXY其他）{
返回Math.sqrt（Math.pow（this.x-other.x，2）
+Math.pow（this.y-other.y，2））；
}

输出应为相同类型的2D数组，但在每个红色圆圈点（在输出数组中的相同位置保持不变）下，应为蓝色部分中距离红色圆圈值最近的点（按欧几里德距离）

这是K-Means聚类的数据结构，每个聚类都是一列（绿色圆圈），第一个点是聚类的中心（红色圆圈），列中的所有其他点（黄色圆圈）都是分配给中心的点

因此，问题是如何迭代输入数组簇，按照描述比较值，并将它们写入数组

clustersorted

---

我想计算蓝色圆圈集合中每个点和红色圆圈中每个值之间的欧几里德距离。然后根据最小欧几里德距离对它们进行排序。因此，在输出数组中，蓝色圆圈集中的每个点将位于红色圆圈中最近的点下方。

创建一个大小为[n][（n-1）*n]的临时浮点/双数组，其中输入矩阵的大小为[n][n-1]

使用第一行中的所有点计算矩阵下部所有点的欧氏距离，并将它们存储在临时阵列中各自的位置

创建每个临时子阵列的副本

对副本执行任何排序操作，最好是选择排序，因为您只需要对数组进行部分排序，直到找到最低的n-1个元素

最后，创建一个大小为[n][n-1]的新输出数组，将最低欧几里德距离对应到它们的点，并将（n-1）点的排序（n-1）元素组存储在它们最近的参考点的正下方。

参见另一个答案：

---

要按列对二维对象数组进行排序，可以先将该数组转置并对每行进行排序，然后将其转置回原处。要使用自定义比较器对从第二个元素开始的元素行按与第一个元素的距离进行排序，可以使用以下方法：

intm=4；
int n=3；
PointXY[][]簇={
{新点XY（23.237633,53.78671），
新点XY（69.15293,17.138134），
新点XY（23.558687，45.70517）}，
{新点XY（47.851738,16.525734），
新点XY（47.802097,16.689285），
新点XY（47.946404,16.732542）}，
{新点XY（47.89601,16.638218），
新点XY（47.833263,16.478987），
新点XY（47.88203,16.45793）}，
{新点XY（47.75438,16.549816），
新点XY（47.915512,16.506475），
新点xy（47.768547，16.67624）}；

//转置矩阵
PointXY[][]转置=新的PointXY[n][m]；
IntStream.range（0，n）.forEach（i->
IntStream.range（0，m）.forEach（j->
转置[i][j]=簇[j][i]）；

//从第二行开始对每行进行排序
//元素与第一个元素的距离
Arrays.stream（转置）.forEach（集群->
Arrays.sort（cluster，1，cluster.length，
比较器。比较器双精度（点->
sqrt（Math.pow（cluster[0].x-point.x，2）
+Math.pow（cluster[0].y-point.y，2‘‘‘‘‘））；

//将矩阵转换回原来的位置
点XY[][]群集=新点XY[m][n]；
IntStream.range（0，m）.forEach（i->
IntStream.range（0，n）.forEach（j->
聚类[i][j]=转置[j][i]）；

//输出
Arrays.stream（clustersorted）.map（Arrays:：toString）.forEach（System.out:：println）；

---

类

PointXY

应如下所示：

[[23.237633,53.78671], [69.15293,17.138134], [23.558687,45.70517]] . . .
[[47.851738,16.525734], [47.802097,16.689285], [47.946404,16.732542]]
[[47.89601,16.638218], [47.833263,16.478987], [47.88203,16.45793]]
[[47.75438,16.549816], [47.915512,16.506475], [47.768547,16.67624]]
.
.
.

公共类PointXY{
双x，y；
公共点XY（双x，双y）{
这个.x=x；
这个。y=y；
}
@凌驾
公共字符串toString（）{
返回x+“，”+y；
}
}

请参阅另一个答案：

---

构建分类集群。第一行是中心点。其他点按最近的中心分组。在这种情况下，所有点都按第二个中心点分组：

PointXY[][]簇={
{新点XY（23.237633,53.78671），
新点XY（69.15293,17.138134），
新点XY（23.558687，45.70517）}，
{新点XY（47.851738,16.525734），
新点XY（47.802097,16.689285），
新点XY（47.946404,16.732542）}，
{新点XY（47.89601,16.638218），
新点XY（47.833263,16.478987），
新点XY（47.88203,16.45793）}，
{新点XY（47.75438,16.549816），
新点XY（47.915512,16.506475），
新点xy（47.768547，16.67624）}；

//中心点的数组
PointXY[]中心=簇[0]；
PointXY[][]群集化=阵列
//在中心点数组上迭代
.溪流（中心）
//对于每个中心点
.map（中心->流）（中心，数组）
//从第二行开始迭代集群数组
斯特里亚先生