写出生成这个矩阵的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语言写出用邻接矩阵作为图的存储结构建立一个网，并构造该网的最小生成树

好的，以下是用C语言实现邻接矩阵存储图并构造最小生成树的代码：

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

#define MAX_VERTICES 100
#define INF INT_MAX

// 邻接矩阵存储图的结构体
typedef struct {
    int n; // 顶点数
    int weight[MAX_VERTICES][MAX_VERTICES]; // 边的权重
} Graph;

// 初始化邻接矩阵图
void init_graph(Graph* g, int n) {
    int i, j;
    g->n = n;
    for (i = 0; i < n; i++) {
        for (j = 0; j < n; j++) {
            g->weight[i][j] = INF;
        }
    }
}

// 添加边
void add_edge(Graph* g, int u, int v, int w) {
    g->weight[u][v] = w;
}

// Prim算法构造最小生成树
void prim(Graph* g, int* parent) {
    int i, j, k, min;
    int u, v;
    int distance[MAX_VERTICES]; // 存储每个顶点到已选择顶点集合的最短距离
    int visited[MAX_VERTICES]; // 记录每个顶点是否已经在已选择顶点集合中
    for (i = 0; i < g->n; i++) {
        distance[i] = g->weight[0][i]; // 初始化为0号顶点到各个顶点的距离
        visited[i] = 0;
        parent[i] = 0; // 初始化0号顶点为各个顶点的父节点
    }
    visited[0] = 1; // 将0号顶点放入已选择顶点集合中
    for (i = 1; i < g->n; i++) {
        min = INF;
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && distance[j] < min) {
                min = distance[j];
                k = j; // 找到离已选择顶点集合最近的顶点
            }
        }
        visited[k] = 1; // 将k号顶点放入已选择顶点集合中
        for (j = 0; j < g->n; j++) {
            if (!visited[j] && g->weight[k][j] < distance[j]) {
                distance[j] = g->weight[k][j]; // 更新未选择顶点到已选择顶点集合的最短距离
                parent[j] = k; // 更新未选择顶点的父节点为k号顶点
            }
        }
    }
}

// 打印最小生成树的边
void print_mst(Graph* g, int* parent) {
    int i;
    printf("Minimum Spanning Tree:\n");
    for (i = 1; i < g->n; i++) {
        printf("(%d, %d)\n", parent[i], i);
    }
}

int main() {
    Graph g;
    int parent[MAX_VERTICES];
    int n = 6; // 顶点数
    init_graph(&g, n);
    add_edge(&g, 0, 1, 6);
    add_edge(&g, 0, 2, 1);
    add_edge(&g, 0, 3, 5);
    add_edge(&g, 1, 2, 5);
    add_edge(&g, 1, 4, 3);
    add_edge(&g, 2, 3, 5);
    add_edge(&g, 2, 4, 6);
    add_edge(&g, 2, 5, 4);
    add_edge(&g, 3, 5, 2);
    add_edge(&g, 4, 5, 6);
    prim(&g, parent);
    print_mst(&g, parent);
    return 0;
}

代码中使用了Prim算法构造最小生成树，时间复杂度为O(n^2)，其中n为顶点数。建议结合代码和注释详细理解实现过程。