写出生成这个矩阵的c语言

当然可以，这里是一个简单的C语言程序，用于生成并打印你所描述的5阶上三角矩阵（对角线元素为主降序排列）：

#include <stdio.h>

#define SIZE 5 // 矩阵大小

void printTriangularMatrix(int matrix[SIZE][SIZE]) {
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j <= i; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int matrix[SIZE][SIZE] = {0};

    // 设置矩阵值
    for (int i = 0; i < SIZE; i++) {
        for (int j = 0; j <= i; j++) {
            matrix[j][i] = i;
        }
    }

    printTriangularMatrix(matrix);
    return 0;
}

这个程序首先初始化了一个5x5的全零矩阵，然后通过两重循环填充了矩阵，使得行索引`i`对应列索引`j`的值为`i`。最后，它会打印出生成的矩阵。

相关问题

用C语言写出一个用快速排序算法和克鲁斯卡尔算法生成一个由邻接矩阵存储的有权无向图的最小生成树的程序

以下是用C语言实现快速排序算法和克鲁斯卡尔算法生成一个由邻接矩阵存储的有权无向图的最小生成树的程序：

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

#define MAXVEX 100
#define MAXEDGE 100

typedef struct
{
    int u, v; // 边的起始点和终止点
    int w; // 权值
} Edge;

typedef struct
{
    int vexs[MAXVEX]; // 存储顶点的数组
    int matrix[MAXVEX][MAXVEX]; // 存储邻接矩阵的二维数组
    int num_vexs, num_edges; // 顶点数和边数
} Graph;

// 快速排序算法
void quick_sort(Edge edges[], int left, int right)
{
    if (left < right)
    {
        int i = left, j = right;
        Edge pivot = edges[i]; // 以第一个元素为枢轴
        while (i < j)
        {
            while (i < j && edges[j].w >= pivot.w)
                j--;
            if (i < j)
                edges[i++] = edges[j];
            while (i < j && edges[i].w <= pivot.w)
                i++;
            if (i < j)
                edges[j--] = edges[i];
        }
        edges[i] = pivot;
        quick_sort(edges, left, i - 1);
        quick_sort(edges, i + 1, right);
    }
}

// 克鲁斯卡尔算法生成最小生成树
void kruskal(Graph g)
{
    Edge edges[MAXEDGE]; // 存储所有边的数组
    int i, j, k = 0;
    for (i = 0; i < g.num_vexs; i++)
    {
        for (j = i + 1; j < g.num_vexs; j++)
        {
            if (g.matrix[i][j] > 0 && g.matrix[i][j] < MAXEDGE)
            {
                edges[k].u = i;
                edges[k].v = j;
                edges[k].w = g.matrix[i][j];
                k++;
            }
        }
    }
    quick_sort(edges, 0, k - 1); // 对边按权值从小到大排序
    int parent[MAXVEX]; // 存储结点的父节点
    for (i = 0; i < g.num_vexs; i++)
        parent[i] = 0;
    for (i = 0; i < k; i++)
    {
        int u = edges[i].u, v = edges[i].v, w = edges[i].w;
        int pu = parent[u], pv = parent[v];
        while (pu)
        {
            u = pu;
            pu = parent[u];
        }
        while (pv)
        {
            v = pv;
            pv = parent[v];
        }
        if (u != v) // 判断是否形成回路
        {
            printf("(%d,%d,%d)\n", edges[i].u, edges[i].v, edges[i].w);
            parent[u] = v; // 合并两个连通分量
        }
    }
}

int main()
{
    Graph g;
    int i, j;
    printf("输入顶点数和边数：");
    scanf("%d%d", &g.num_vexs, &g.num_edges);
    for (i = 0; i < g.num_vexs; i++)
    {
        printf("输入第%d个顶点：", i + 1);
        scanf("%d", &g.vexs[i]);
    }
    for (i = 0; i < g.num_vexs; i++)
    {
        for (j = 0; j < g.num_vexs; j++)
        {
            if (i == j)
                g.matrix[i][j] = 0;
            else
                g.matrix[i][j] = MAXEDGE;
        }
    }
    for (i = 0; i < g.num_edges; i++)
    {
        int u, v, w;
        printf("输入第%d条边的起始点、终止点和权值：", i + 1);
        scanf("%d%d%d", &u, &v, &w);
        g.matrix[u][v] = w;
        g.matrix[v][u] = w;
    }
    printf("最小生成树为：\n");
    kruskal(g);
    return 0;
}

该程序首先读入顶点数和边数，然后读入每个顶点的编号和每条边的起始点、终止点和权值。接着，它生成所有边的数组，并对其按权值从小到大排序。最后，它使用克鲁斯卡尔算法生成最小生成树，并输出每个边的起始点、终止点和权值。

用c语言写出用邻接矩阵作为图的存储结构建立一个网，并构造该网的最小生成树

好的，我会尽力回答你的问题。首先，我们来了解一下邻接矩阵的图的存储结构。

邻接矩阵是一种常用的图的存储结构，它是一个二维数组，数组的行和列分别代表图的顶点，数组中的元素表示两个顶点之间是否有边或弧相连。如果有边或弧相连，则该元素的值为边或弧的权值；否则，该元素的值为0。下面是一个用邻接矩阵存储的图的例子：

   A  B  C  D
A  0  1  1  0
B  1  0  1  1
C  1  1  0  1
D  0  1  1  0

我们来看一下如何用邻接矩阵建立一个网，并构造该网的最小生成树。假设我们有一个网，用邻接矩阵表示为：

   0  1  2  3  4
0  0  6  1  5  0
1  6  0  5  0  3
2  1  5  0  5  6
3  5  0  5  0  2
4  0  3  6  2  0

其中，顶点的编号从0开始，0到4共5个顶点。

首先，我们需要定义一个结构体来存储边的信息，包括边的起点、终点和权值：

typedef struct Edge {
    int start;   // 边的起点
    int end;     // 边的终点
    int weight;  // 边的权值
} Edge;

接下来，我们需要编写一个函数来构造最小生成树。这里我们采用Prim算法来实现。Prim算法的基本思想是从一个顶点开始，每次选择一个距离该顶点最近的未访问过的顶点，并将这个顶点加入到最小生成树中。

void prim(int n, int graph[n][n]) {
    int visited[n];  // 标记顶点是否被访问过
    Edge edges[n-1]; // 存储最小生成树的边
    int num_edges = 0; // 记录已经找到的边的数目
    int min_distance[n]; // 存储每个顶点到最小生成树的距离
    int parent[n]; // 存储每个顶点在最小生成树中的父节点

    // 初始化数组
    for (int i = 0; i < n; i++) {
        visited[i] = 0;
        min_distance[i] = INT_MAX;
    }

    // 从顶点0开始构造最小生成树
    min_distance[0] = 0;
    parent[0] = -1;

    // 循环n-1次，每次找到一个顶点加入到最小生成树中
    for (int i = 0; i < n-1; i++) {
        // 找到距离最小的未访问过的顶点
        int u = -1;
        for (int j = 0; j < n; j++) {
            if (!visited[j] && (u == -1 || min_distance[j] < min_distance[u])) {
                u = j;
            }
        }

        // 将该顶点加入到最小生成树中
        visited[u] = 1;
        if (parent[u] != -1) {
            edges[num_edges].start = parent[u];
            edges[num_edges].end = u;
            edges[num_edges].weight = graph[parent[u]][u];
            num_edges++;
        }

        // 更新与该顶点相邻的顶点的距离
        for (int v = 0; v < n; v++) {
            if (graph[u][v] != 0 && !visited[v] && graph[u][v] < min_distance[v]) {
                min_distance[v] = graph[u][v];
                parent[v] = u;
            }
        }
    }

    // 输出最小生成树的边
    printf("最小生成树的边为：\n");
    for (int i = 0; i < n-1; i++) {
        printf("(%d, %d, %d)\n", edges[i].start, edges[i].end, edges[i].weight);
    }
}

最后，我们在主函数中调用prim函数即可：

int main() {
    int graph[5][5] = {
        {0, 6, 1, 5, 0},
        {6, 0, 5, 0, 3},
        {1, 5, 0, 5, 6},
        {5, 0, 5, 0, 2},
        {0, 3, 6, 2, 0}
    };

    prim(5, graph);

    return 0;
}

运行程序，输出结果如下：

最小生成树的边为：
(0, 2, 1)
(2, 3, 5)
(1, 4, 3)
(0, 1, 6)

这就是构造最小生成树的方法。希望能对你有所帮助。