目前，有100个数据存放在数组mid_time中，要求使用c++对这一百个数据进行聚类，使用层次聚类并且聚类依据数据的差值。

好的，针对您的问题，我可以给出一个简单的层次聚类的实现，供您参考。

首先，我们可以定义一个数据结构来存储每个数据点，包括时间和数值：

struct DataPoint {
    double time; // 时间
    double value; // 数值
};

然后，我们可以定义一个函数来计算两个数据点之间的距离（差值）：

double distance(const DataPoint& a, const DataPoint& b) {
    return abs(a.value - b.value);
}

接着，我们可以使用一个二维数组来存储每个数据点之间的距离，以便于后续的聚类操作：

double distances[100][100];
for (int i = 0; i < 100; ++i) {
    for (int j = i + 1; j < 100; ++j) {
        distances[i][j] = distance(mid_time[i], mid_time[j]);
    }
}

最后，我们可以使用一个循环来进行层次聚类，每次选择距离最近的两个簇进行合并，直到只剩下一个簇为止。在每次合并簇时，我们可以使用一个新的数据结构来存储簇的信息：

struct Cluster {
    vector<int> indices; // 簇中包含的数据点的下标
    double distance; // 簇内数据点之间的平均距离
};

完整的代码如下：

#include <iostream>
#include <vector>
#include <cmath>
using namespace std;

struct DataPoint {
    double time;
    double value;
};

double distance(const DataPoint& a, const DataPoint& b) {
    return abs(a.value - b.value);
}

int main() {
    // 假设有100个数据点
    DataPoint mid_time[100];

    // 计算每个数据点之间的距离
    double distances[100][100];
    for (int i = 0; i < 100; ++i) {
        for (int j = i + 1; j < 100; ++j) {
            distances[i][j] = distance(mid_time[i], mid_time[j]);
        }
    }

    // 初始化簇
    vector<Cluster> clusters;
    for (int i = 0; i < 100; ++i) {
        Cluster cluster;
        cluster.indices.push_back(i);
        cluster.distance = 0;
        clusters.push_back(cluster);
    }

    // 层次聚类
    while (clusters.size() > 1) {
        // 找到距离最近的两个簇
        double min_distance = distances[clusters[0].indices[0]][clusters[1].indices[0]];
        int min_i = 0, min_j = 1;
        for (int i = 0; i < clusters.size(); ++i) {
            for (int j = i + 1; j < clusters.size(); ++j) {
                double distance = 0;
                for (int k = 0; k < clusters[i].indices.size(); ++k) {
                    for (int l = 0; l < clusters[j].indices.size(); ++l) {
                        distance += distances[clusters[i].indices[k]][clusters[j].indices[l]];
                    }
                }
                distance /= clusters[i].indices.size() * clusters[j].indices.size();
                if (distance < min_distance) {
                    min_distance = distance;
                    min_i = i;
                    min_j = j;
                }
            }
        }

        // 合并簇
        clusters[min_i].indices.insert(clusters[min_i].indices.end(),
                                        clusters[min_j].indices.begin(),
                                        clusters[min_j].indices.end());
        clusters[min_i].distance = min_distance;
        clusters.erase(clusters.begin() + min_j);
    }

    // 输出聚类结果
    for (int i = 0; i < clusters[0].indices.size(); ++i) {
        cout << clusters[0].indices[i] << " ";
    }
    cout << endl;

    return 0;
}

需要注意的是，上述代码仅仅是一个简单的层次聚类的实现，可能存在一些问题，如效率较低、结果不稳定等。如果需要更加严谨和高效的聚类算法，可以参考一些成熟的聚类库，如`scikit-learn`等。