python凝聚层次聚类算法实现（非聚类库函数调用），要求算法输入：随机生成聚类的>=20个对象；算法输出：分类结果，聚类过程中得到的最短距离值以及距离矩阵。考虑单链法single-linkage、全链法complete-linkage和组平均法average-linkage这三种不同距离的计算方法进行聚类。

好的，这是一个比较复杂的问题，需要分步骤来回答。首先，我们需要了解一下凝聚层次聚类算法的基本原理。

凝聚层次聚类算法是一种自下而上的聚类方法，它的基本思想是从每个数据点开始，逐步将相似的数据点合并成一个簇，直到所有数据点都被合并成为一个簇或者达到指定的簇的个数。其中，相似度的计算方法可以采用不同的距离度量方式，如欧几里得距离、曼哈顿距离、余弦相似度等。在本次问题中，我们需要实现三种不同距离度量方式的凝聚层次聚类算法，分别是单链法、全链法和组平均法。

下面，我将分步骤介绍如何实现这个算法。首先是数据的生成。我们可以使用numpy库来生成随机数据，代码如下：

import numpy as np

np.random.seed(0)
X = np.random.rand(20, 5)  # 生成20个5维随机向量

接下来，我们需要计算两两数据点之间的距离，并构建距离矩阵。这里我们可以使用scipy库中的distance函数来计算距离。代码如下：

from scipy.spatial.distance import pdist, squareform

distances = pdist(X, metric='euclidean')  # 计算欧几里得距离
distance_matrix = squareform(distances)  # 将距离向量转换为距离矩阵

接下来是凝聚层次聚类的核心代码。我们可以使用一个列表来存储每个数据点的簇标记，初始时每个数据点都是一个簇，簇标记为数据点的下标。然后，我们可以使用一个字典来存储每个簇的距离，初始时每个簇的距离为无穷大。在聚类过程中，我们需要不断地找到距离最小的两个簇进行合并，直到达到指定的簇的个数。每次合并簇时，我们需要更新每个簇的距离，并将被合并的簇的标记更新为合并后的簇的标记。最后，我们可以返回聚类结果、最短距离值以及距离矩阵。代码如下：

def agglomerative_clustering(X, n_clusters, linkage='single'):
    n_samples = X.shape[0]
    labels = np.arange(n_samples)  # 初始时每个数据点都是一个簇，簇标记为数据点的下标
    distances = {i: {j: distance_matrix[i, j] for j in range(i + 1, n_samples)} for i in range(n_samples)}
    # 初始时每个簇的距离为无穷大
    cluster_distances = {i: float('inf') for i in range(n_samples)}

    def update_distances(i, j, k):
        # 更新簇k与其他簇的距离
        for l in range(n_samples):
            if l not in (i, j, k):
                if linkage == 'single':
                    d = min(distances[i][l], distances[j][l])
                elif linkage == 'complete':
                    d = max(distances[i][l], distances[j][l])
                elif linkage == 'average':
                    d = (distances[i][l] + distances[j][l]) / 2
                distances[k][l] = d
        # 删除簇i和簇j
        del distances[i], distances[j]
        # 更新簇距离
        for l in distances:
            if l != k:
                if linkage == 'single':
                    cluster_distances[l] = min(cluster_distances[l], distances[k][l])
                elif linkage == 'complete':
                    cluster_distances[l] = max(cluster_distances[l], distances[k][l])
                elif linkage == 'average':
                    cluster_distances[l] = (cluster_distances[l] + distances[k][l]) / 2

    for n_clusters in range(n_samples, n_clusters, -1):
        # 找到距离最小的两个簇进行合并
        i, j = min(((i, j) for i in distances for j in distances[i]), key=lambda x: distances[x[0]][x[1]])
        k = n_samples - n_clusters
        # 更新簇标记
        labels[labels == i] = k
        labels[labels == j] = k
        # 更新距离矩阵
        distances[k] = {l: distances[i][l] for l in distances[i]}
        distances[k].update({l: distances[j][l] for l in distances[j]})
        update_distances(i, j, k)

    return labels, cluster_distances, distance_matrix

最后，我们可以使用上面的代码来分别实现单链法、全链法和组平均法的聚类。代码如下：

labels_single, distances_single, distance_matrix_single = agglomerative_clustering(X, 5, linkage='single')
labels_complete, distances_complete, distance_matrix_complete = agglomerative_clustering(X, 5, linkage='complete')
labels_average, distances_average, distance_matrix_average = agglomerative_clustering(X, 5, linkage='average')

其中，n_clusters参数指定最终要聚成的簇的个数。这里我们聚成了5个簇。最后，我们可以输出聚类结果、最短距离值以及距离矩阵。代码如下：

print('Single linkage:')
print('Labels:', labels_single)
print('Distances:', distances_single)
print('Distance matrix:\n', distance_matrix_single)

print('Complete linkage:')
print('Labels:', labels_complete)
print('Distances:', distances_complete)
print('Distance matrix:\n', distance_matrix_complete)

print('Average linkage:')
print('Labels:', labels_average)
print('Distances:', distances_average)
print('Distance matrix:\n', distance_matrix_average)

注意，这里的距离矩阵是一个对称矩阵，因此只需要输出其中的一半就可以了。

希望我的回答能够帮助你解决问题。如果还有任何疑问，欢迎继续追问！