在n个城市之间建设网络，只需保证连通即可，求最经济的架设方法。存储结构自定。要求用克鲁什卡尔算法求解，如有优化，要有优化过程,用C语言实现

以下是基于 C 语言实现 Kruskal 算法的示例代码，其中使用了路径压缩和按秩合并两种优化方式：

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int u, v, w;
} Edge;

int cmp(const void *a, const void *b) {
    return ((Edge *)a)->w - ((Edge *)b)->w;
}

int find(int *parent, int x) {
    if (parent[x] != x) {
        parent[x] = find(parent, parent[x]);
    }
    return parent[x];
}

void union_by_rank(int *parent, int *rank, int x, int y) {
    int px = find(parent, x);
    int py = find(parent, y);
    if (px == py) {
        return;
    }
    if (rank[px] < rank[py]) {
        parent[px] = py;
    } else if (rank[px] > rank[py]) {
        parent[py] = px;
    } else {
        parent[px] = py;
        rank[py]++;
    }
}

Edge *kruskal(int n, Edge *edges, int m, int *count) {
    Edge *result = (Edge *)malloc((n - 1) * sizeof(Edge));
    int *parent = (int *)malloc(n * sizeof(int));
    int *rank = (int *)calloc(n, sizeof(int));
    int i, j, k = 0;
    for (i = 0; i < n; i++) {
        parent[i] = i;
    }
    qsort(edges, m, sizeof(Edge), cmp);
    for (i = 0, j = 0; i < n - 1 && j < m; j++) {
        if (find(parent, edges[j].u) != find(parent, edges[j].v)) {
            union_by_rank(parent, rank, edges[j].u, edges[j].v);
            result[k++] = edges[j];
            i++;
        }
    }
    *count = k;
    free(parent);
    free(rank);
    return result;
}

int main(void) {
    int n, m, i, count;
    printf("Enter number of cities: ");
    scanf("%d", &n);
    m = n * (n - 1) / 2;
    Edge *edges = (Edge *)malloc(m * sizeof(Edge));
    k = 0;
    for (i = 0; i < n - 1; i++) {
        int j;
        for (j = i + 1; j < n; j++) {
            int w;
            printf("Enter cost of connecting city %d and city %d: ", i + 1, j + 1);
            scanf("%d", &w);
            edges[k++] = (Edge){i, j, w};
        }
    }
    Edge *result = kruskal(n, edges, m, &count);
    printf("Minimum spanning tree:\n");
    for (i = 0; i < count; i++) {
        printf("(%d, %d): %d\n", result[i].u + 1, result[i].v + 1, result[i].w);
    }
    free(edges);
    free(result);
    return 0;
}

在实现中，我们首先定义了一个 `Edge` 结构体来表示一条边，然后实现了一个 `cmp` 函数来对边按照权值从小到大排序。

接着，我们实现了 `find` 函数来查找节点的根节点，并使用路径压缩优化。我们还实现了 `union_by_rank` 函数来按照节点的秩进行合并，并使用按秩合并优化。

最后，我们实现了 `kruskal` 函数来实现 Kruskal 算法，使用了上述两种优化方式。在函数中，我们首先初始化并查集，并将所有边按照权值从小到大排序。然后依次取出每条边，如果这条边所连接的两个城市尚未连通，则将它们连通，并将这条边加入最小生成树中。最后返回最小生成树中的所有边。

在 `main` 函数中，我们首先读入城市数量和每个城市之间的连接成本。然后使用 Kruskal 算法求解最小生成树，并输出结果。

注意，由于 Kruskal 算法的时间复杂度为 $O(m\log m)$，其中 $m$ 是边的数量，因此在输入城市数量较大时，时间复杂度可能会比较高。如果需要优化，可以考虑使用 Prim 算法等其他最小生成树算法。