精华内容
下载资源
问答
  • C语言实现稀疏矩阵转置
    2021-10-22 15:25:53
    //
    //Created by zhuoL on 2021/10/20.
    //
    #include <stdio.h>
    #include <stdlib.h>
    // 非零元最大个数
    #define MAXSIZE 20
    // 定义三元组
    typedef struct {
        int i, j, e;//行 列 非零元素值
    } Triple;
    // 定义稀疏矩阵
    typedef struct {
        Triple data[MAXSIZE + 1];
        int mu, nu, tu;//行 列 非零元素的个数
    } SMatrix;
    
    void printSMatrix(SMatrix *m) {
        int index = 1, test = 0;
        int i, j;
        for (i = 1; i <= m->mu; i++) {
            for (j = 1; j <= m->nu; j++) {
                index = 1;
                while (index <= m->tu) {
                    if (i == m->data[index].i && j == m->data[index].j) {
                        printf("%-4d", m->data[index].e);
                        //index++;
                        break;
                    }
                    index++;
                }
                if (index > m->tu) {
                    printf("%-4d", test);
                }
            }
            printf("\n");
        }
    }
    
    SMatrix *createSMatrix() {
        SMatrix *m = (SMatrix *) malloc(sizeof(SMatrix));
        int i = 1, number;
    
        //printf("请输入稀疏矩阵的行数,列数:\n");
        scanf("%d%d", &m->mu, &m->nu);
        flag1:
        //printf("请输入非零元的个数:\n");
        scanf("%d", &number);
        //如果非零元素个数>=矩阵总元素的30% 则重新输入
        if (number >= (m->mu * m->nu) * 0.3) {
            //printf("非零元素个数不合格重新输入\n");
            goto flag1;
        }
        m->tu = number;
        //printf("请依次输入元素的行号,列号与数据:\n");
        int line, column, data;
        do {
            flag:
            scanf("%d%d%d", &line, &column, &data);
            if ((line < m->data[i - 1].i) ||
                ((line == m->data[i - 1].i) && column < m->data[i - 1].j)) {
                goto flag;
            }
            m->data[i].i = line;
            m->data[i].j = column;
            m->data[i].e = data;
            ++i;
        } while (i <= m->tu);
        printf("Before:\n");
        printSMatrix(m);
        return m;
    }
    
    SMatrix *fastTranspose(SMatrix *m) {
        // 转置矩阵
        SMatrix *t = (SMatrix *) malloc(sizeof(SMatrix));
        t->mu = m->nu;
        t->nu = m->mu;
        t->tu = m->tu;
    
        if (t->tu) {
            // 保存矩阵每一列非零元的个数
            int a, b, c;
            int *num = (int *) malloc(sizeof(int) * (m->nu + 1));
            for (a = 1; a <= m->nu; a++) {
                num[a] = 0;
            }
            for (b = 1; b <= m->tu; b++) {
                num[m->data[b].j]++;
            }
            // 每一列第一个非零元的位置
            int *cpot = (int *) malloc(sizeof(int) * (m->nu + 1));
            cpot[1] = 1;
            for (c = 2; c <= m->nu; c++) {
                cpot[c] = cpot[c - 1] + num[c - 1];
            }
            int d;
            // 遍历矩阵M,开始转置
            for (d = 1; d <= m->tu; d++) {
                // 取出该元素的列号
                int col = m->data[d].j;
                // 确定存放位置
                int q = cpot[col];
                t->data[q].i = m->data[d].j;
                t->data[q].j = m->data[d].i;
                t->data[q].e = m->data[d].e;
                cpot[col]++;
            }
        }
    
        //printf("\n转置后的矩阵:\n");
        printf("After:\n");
        printSMatrix(t);
        return t;
    }
    
    int main() {
        SMatrix *sMatrix = createSMatrix();
        fastTranspose(sMatrix);
        return 0;
    }
    
    
    更多相关内容
  • 数据结构,稀疏矩阵快速转置c语言算法,时间复杂性为O(n+t)。
  • 稀疏矩阵转置C语言

    千次阅读 多人点赞 2021-03-29 19:57:25
    最近有数据结构实验课了,还得学一学数据结构喽,以后就把学习经过贴上来了。 稀疏矩阵 ...稀疏矩阵转置 题目 (不得不说这个题输入数据的确坑。。) 有两种方法转置 话不多说,上代码: #include<stdi

    最近有数据结构实验课了,还得学一学数据结构喽,以后就把学习经过贴上来了。

    稀疏矩阵

    当一个数组中大部分元素为0,或者为同一个值的数组时,可以使用稀疏数组来保存该数组

    稀疏数组的处理方法

    1)记录数组一共有几行几列,有多少个不同的值(假设有sum个,则稀疏矩阵有sum+1行,3列)
    2)把具有不同值的元素的行列及值记录在一个小规模的数组中,从而缩小程序的规模
    百度盗图
    百度盗图(手动滑稽)

    稀疏矩阵转置

    题目
    在这里插入图片描述
    (不得不说这个题输入数据的确坑。。)
    有两种方法转置
    话不多说,上代码:

    #include<stdio.h>
    #include<stdlib.h>
    
    #define MAXSIZE 1000
    typedef struct{
    int row;//第几行
    int col;//第几列
    int e;//存储的值
    }Triple;
    
    typedef struct
    {
        Triple data[MAXSIZE];
        int m,n,len;//稀疏矩阵的行,列,非零元素的个数
    }TSMatrix;
    
    
    void createTSMatrix(TSMatrix *A)//创建矩阵
    {    int i=1;     //data【0】未用
        scanf("%d %d",&A->m,&A->n);
        int flag = 1;
        int a,b,c;
        char c1,c2;
        while(flag)
        {
            scanf("%d",&a);
            c1 = getchar();
             scanf("%d",&b);
             c2 = getchar();
              scanf("%d",&c);
              if(c1=='?'&&c2=='?')
                break;
              A->data[i].row=a;
              A->data[i].col=b;
              A->data[i].e=c;
              i++;
    
        }
        i--;
        A->len=i;
    }
    
    void TransMatrix(TSMatrix A,TSMatrix *B)//序列递增转置法
    {
        int i,j,k;
        B->n=A.m;
        B->m=A.n;
        B->len=A.len;
        if(B->len)
        {
            j=1;//辅助计数器,记录转置后的三元组元素下标值
            for(k=1;k<=A.n;k++)//扫描矩阵A的列次或B的行次
    
                for(i=1;i<=A.len;i++)  //扫描A找列为k的元素
            {
                if(A.data[i].col==k)
                {
                    B->data[j].row=A.data[i].col;
                    B->data[j].col=A.data[i].row;
                    B->data[j].e=A.data[i].e;
                    j++;
                }
            }
        }
    }
    
    void FastTransMatrix(TSMatrix A,TSMatrix *B)//快速转置法
    {
        int col,t,p,q;
        int num[MAXSIZE],position[MAXSIZE];
        B->n=A.m;
        B->m=A.n;
        B->len=A.len;
        if(B->len)
        {
            for(col=1;col<=A.n;col++)
                num[col]=0;
            for(t=1;t<=A.len;t++)
                num[A.data[t].col]++;
            position[1]=1;
            for(col=2;col<=A.n;col++)
            {
                position[col]=position[col-1]+num[col-1];
            }
            for(p=1;p<=A.len;p++)
            {
                col=A.data[p].col;
                q=position[col];
                B->data[q].row=A.data[p].col;
                B->data[q].col=A.data[p].row;
                B->data[q].e=A.data[p].e;
                position[col]++;
            }
        }
    }
    
    void printMatrix(TSMatrix *B)//输出矩阵
    {
        for(int i=1;i<=B->len;i++)
        {
            printf("%d %d %d\n",B->data[i].row,B->data[i].col,B->data[i].e);
        }
    }
    
    int main()
    {
        TSMatrix A,B;//A为初始矩阵,B为转置后的矩阵
        createTSMatrix(&A);
        FastTransMatrix(A,&B);
        printMatrix(&B);
        return 0;
    }
    
    

    在这里插入图片描述

    展开全文
  • 稀疏矩阵转置算法(C语言

    千次阅读 2022-04-03 14:40:20
    稀疏矩阵的压缩:将矩阵中的值为零或者为常数C的某c个数,不做存储(或者共用同样的空间,本题转置对0不做存储),压缩后原本nxn的矩阵,存储只需要nxn-c的空间 下面以这样的M矩阵进行转置 1 2 3 4 0 0 0 5 1 转置后...

    (参考数据结构教材,严蔚敏,吴伟民版 p99,多谢阅读,望对您有帮助)
    无论是几维的数组,在计算机中都是以一维数组的方式进行存储的。
    矩阵:相当于二维数组,它的存储,依然是用一维数组的方式进行存储。
    nxn的矩阵,在计算机空间上,需要nxn个空间
    稀疏矩阵的压缩:将矩阵中的值为零或者为常数C的某c个数,不做存储(或者共用同样的空间,本题转置对0不做存储),压缩后原本nxn的矩阵,存储只需要nxn-c的空间
    下面以这样的M矩阵进行转置
    1 2 3
    4 0 0
    0 5 1
    转置后得N矩阵
    1 4 0
    2 0 5
    3 0 1
    M矩阵的计算机三元组存储方式(此图为图1)
    在这里插入图片描述
    转置后T矩阵的计算机三元组存储方式(此图为图2)
    在这里插入图片描述
    转置过程的实现,实际上是从图一转化为图二的过程
    因为图1是按照行储存(第一行储存完了,才储存第二行),转置后的T矩阵,同样是按照行进行存储。
    故T矩阵再遍历矩阵M时,M的列就是T的行把M的每列的数据,逐列,一一存到data中,完成转置运算

    先给出转置代码实现:

    #include "stdio.h"
    #include "stdlib.h"
    
    #define Max_size 1000
    
    typedef struct 
    {
    	int i;//矩阵中数据的行号
    	int j;//矩阵中数据的列号
    	int e;//i行j列,数据的值
    }Triple;//三元组为一个节点
    
    typedef struct
    {
    	Triple data[Max_size + 1];//data[0]未用
    	int mu, nu, tu;//矩阵的行数,列数,非零元个数
    }Matrix;
    
    void TransposeSMatrix(Matrix M,Matrix &T)//将矩阵M转置为T
    {
    	T.mu = M.nu; T.nu = M.mu; T.tu = M.tu;
    	if (T.tu)//非零元不为0
    	{
    		int q = 1;//用于逐项记录转置后矩阵T的值
    		int col, p;//矩阵M的col列号,p:指向当前值在M矩阵硬件的储存位置
    		for (col = 1; col < M.nu; col++)
    		{
    			for (p = 1; p < M.tu; p++)
    			{
    				if (M.data[p].j == col)//逐列进行遍历,并插入到T.data中
    				{
    					T.data[q].i = M.data[p].j;
    					T.data[q].j = M.data[p].i;//转置后i,j互换
    					T.data[q].e = M.data[p].e;//T的值获取到
    					q++;//T指针的数据后移
    				}
    			}
    		}
    	}
    }
    
    int main()
    {
    	Matrix M,T;
    	M.mu = 3;
    	M.nu = 3;
    	M.tu = 6;
    	M.data[1].i = 1;
    	M.data[1].j = 1;
    	M.data[1].e = 1;
    
    	M.data[2].i = 1;
    	M.data[2].j = 2;
    	M.data[2].e = 2;
    
    	M.data[3].i = 1;
    	M.data[3].j = 3;
    	M.data[3].e = 3;
    
    	M.data[4].i = 2;
    	M.data[4].j = 1;
    	M.data[4].e = 4;
    
    	M.data[5].i = 3;
    	M.data[5].j = 2;
    	M.data[5].e = 5;
    
    	M.data[6].i = 3;
    	M.data[6].j = 3;
    	M.data[6].e = 1;
    
    	TransposeSMatrix(M, T);
    	printf("(%d,%d):%d", T.data[4].i, T.data[4].j, T.data[4].e);//求转置后T矩阵2行3列的值
    	return 0;
    }
    

    运行结果
    转置后T矩阵2行3列的值为5,如运行结果所示
    在这里插入图片描述

    展开全文
  • 输入的非零元素个数必须满足稀疏矩阵要求,输入过程检测是否满足此要求,若不满足,则重新输入非零元素个数; 2. 非零元素按行号从小到大顺序输入,相同行号的元素,列号从小到大输入,输入过程检测是否满足此要求...

    问题描述

      输入矩阵的行数、列数和非零元素个数,以及所有非零元素,非零元素包括每个元素的行号、列号、元素值。
    
      要求:1. 输入的非零元素个数必须满足稀疏矩阵要求,输入过程检测是否满足此要求,若不满足,则重新输入非零元素个数;
            2. 非零元素按行号从小到大顺序输入,相同行号的元素,列号从小到大输入,输入过程检测是否满足此要求,若不满足,则重新输入当前非零元素的行号、列号和元素值
            
    

    了解什么是稀疏矩阵

    /**
     * 稀疏矩阵: 是指矩阵中大多数元素为 0 的矩阵。从直观上讲,当非零元素个数低于总元素的 30%
     * 时,这样的矩阵为稀疏矩阵
     *  1. 稀疏矩阵的三元组存储表示
     *      对于稀疏矩阵的存储压缩,采取只存储非零元素的方法。由于稀疏矩阵中非零元素 a_i_j 的分布没有
     *      规律,因此再存储非零元素值的同时,还必须存储该非零元素在矩阵中所处的行号和列号的位置,这就是
     *      稀疏矩阵的三元组表 表示法。
     *
     *  三元组结构:
     *      该非零元素所在的行值       该非零元素所在的列值       该非零元素的值
     *              row                     col                 e
     *
     *   说明: 为处理方便,将稀疏矩阵中非零元素的三元组按照 "行序为主序" 的一维结构体数组进行存放,
     *        将矩阵的每一行(行由小到大)的全部非零元素的三元组按列号递增存放.
     *
     *   矩阵转置:
     *      指变换元素的位置,把位于(row,col) 位置上的元素转换到(col,row)位置上,即把元素的行列互换
     *
     */
    
    

    输入数据样例

    第一组数据:
    行 	列 	数据元素值
    3 	5 		4
    --------------------
    1 	1 		1
    1 	4 		32
    2 	3 		4
    3 	2 		15
    
    第二组数据:
    行 	列 	数据元素值
    3 	5 		4
    --------------------
    1 	1 		1
    1 	4 		32
    2 	3 		4
    2  	1 		15
    3   2       15
    
    
    第三组数据:
    行 	列 	数据元素值
    3 	5 		6
    
    非零元素不满足条件重新输入: 4
    --------------------
    1 	1 		1
    1 	4 		32
    2 	3 		4
    3   2       15
    
    

    解决方案

    #include <stdio.h>
    
    /* 非零元素的个数最多为 255 */
    #define MAX_SIZE 255
    
    typedef int ElementType;
    
    typedef struct {
        /* 非零元素的行下标 */
        int row;
        /* 非零元素的列下标 */
        int col;
        /* 该非零元素的值 */
        ElementType e;
    } Triple;
    
    
    typedef struct {
        /* 该非零元素的三元组表 MAX_SIZE+1: 表示 data[0] 为使用 */
        Triple data[MAX_SIZE + 1];
        /* 矩阵的行数 */
        int rows;
        /* 矩阵的列数 */
        int cols;
        /* 矩阵的非零元素个数 */
        int length;
    } TSMatrix;
    
    
    
    
    /**
     * 稀疏矩阵列序递增转置算法
     * @param A 原矩阵
     * @param B 转置后
     */
    void TransposeTSMatrix(TSMatrix A, TSMatrix *B);
    
    void printT(TSMatrix B);
    
    void InputT(TSMatrix *A);
    int main() {
        TSMatrix A, B;
        InputT(&A);
    
        /* 转置前输出 */
        printf("Before:\n");
        printT(A);
    
        TransposeTSMatrix(A, &B);
    
        /* 转置后输出 */
        printf("After:\n");
        printT(B);
    
        return 0;
    }
    
    void TransposeTSMatrix(TSMatrix A, TSMatrix *B) {
        /* 把矩阵 A 转置到 B 所指向的矩阵中去。矩阵用三元组表示 */
        int i, j, k;
        /* B的行 = A 的列 */
        B->rows = A.cols;
        /* B的列 = A的行 */
        B->cols = A.rows;
        /* 矩阵元素个数相同 */
        B->length = A.length;
    
        /* 如果 B元素个数大于 0 */
        if (B->length > 0) {
            /* j为辅助计数器,记录转置后的三元组在三元组表B中的下标值 */
            j = 1;
            /* 扫描三元组表 A共 A.cols,每次寻找到列值为 k 的三元组进行转置 */
            for (k = 1; k <= A.cols; k++) {
                for (i = 1; i <= A.length; i++) {
                    /* 从头到尾扫描三元组表A,寻找 col 值为 k 的三元组进行转置 */
                    if (A.data[i].col == k) {
                        B->data[j].row = A.data[i].col;
                        B->data[j].col = A.data[i].row;
                        B->data[j].e = A.data[i].e;
                        /* 计数器 j 加 1,指向本行下一个转置后元素的位置下标 */
                        j++;
                    }
                } /* inner for end */
            } /* out for end */
        } /* if end */
    } /* TransposeTSMatrix end */
    
    
    void printT(TSMatrix B) {
        int i, j;
        int t = 1;
        int zero = 0;
        for (i = 1; i <= B.rows; i++) {
            for (j = 1; j <= B.cols; j++) {
                if (B.data[t].row == i && B.data[t].col == j) {
                    printf("%-4d", B.data[t].e);
                    t++;
                } else printf("%-4d", zero);
            }
            printf("\n");
        }
    }
    
    void InputT(TSMatrix *A) {
        int i;
        /*
         * 目标:
         *    存储一个三元组
         *      1. 先满足输入的行列条件
         *      2. 再满足非零元素个数
         *      3. 实现三元组创建
         * */
    
        /* 第一次输入行列: 获取对应矩阵的行数和列数 */
        scanf("%d%d", &A->rows, &A->cols);
    
        /* 输入的非零元素个数必须满足稀疏矩阵要求,输入过程检测是否满足此要求,若不满足,则重新输入非零元素个数 */
        do {
            /* 输入非零元素个数 */
            scanf("%d", &A->length);
            /* 如果非零元素个数大于 4,重新输入 => 矩阵大小为 3 行 5 列,6 个非零元素;(6 个非零元素,不是稀疏矩阵,输入错误) */
        } while ((A->length > (A->rows * A->cols * 0.3))); /* 限制非零元素个数的 do...while end  */
    
        /* 非零元素个数满足后: 输入第一组矩阵表元素 */
        scanf("%d%d%d", &A->data[1].row, &A->data[1].col, &A->data[1].e);
    
        /**
        *  非零元素按行号从小到大顺序输入,相同行号的元素,列号从小到大输入,输入过程检测是否满足此要求,
        *  若不满足,则重新输入当前非零元素的行号、列号和元素值
        */
        for (i = 2; i <= A->length; i++) {
            do {
                /* 输入三元组表: 获取对应位置下标的值 */
                scanf("%d%d%d", &A->data[i].row, &A->data[i].col, &A->data[i].e);
            } while (A->data[i].row < A->data[i - 1].row ||
                     A->data[i].row == A->data[i - 1].row && A->data[i].col <= A->data[i - 1].col);
        }
    }
    

    结果输出

    在这里插入图片描述

    展开全文
  • 实现了从字符文件读入三个正整数m, n, t以及t个三元组(i, j, e)建立稀疏矩阵的十字链表存储结构(m、n分别表示矩阵行数和列数;i, j为非零元素行号和列号)和十字链表的转置并将转置后的三元组到另一字符文件中
  • 稀疏矩阵是指矩阵中大多数元素为零的矩阵。从直观上讲,当非零元素个数低于总元素的30%时,这样的矩阵为稀疏矩阵
  • 基于十字链表的稀疏矩阵转置
  • 三元组稀疏矩阵转置c

    2020-10-18 19:06:25
    #include <iostream> #include<cstdio> using namespace std; #define MAXSIZE 100 //三元组的定义 typedef struct { int row, col;//表示行列 int e; //表示值 ...//实现转置 voi
  • 通过下列代码解释: 这么说吧,刚开始我也不是很理解。在经过一段时间研究后才枉然大悟。 1.首先说下,在以三元组表的形式存矩阵元素时。...3.而在快速转置的方法中 cpot【】保存的是正确的行序,所以可以直接行,
  • 输入第1行为矩阵行数m、列数n及非零元素个数t。 按行优先顺序依次输入t行,每行3个数,分别表示非零元素的行标、列标和值。 输出格式: 输出转置后的三元组顺序表结果,每行输出非零元素的行标、列标和值,行标、列...
  • C语言实现稀疏矩阵

    2020-08-30 11:56:59
    主要为大家详细介绍了C语言实现稀疏矩阵的代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C语言数据结构之两个稀疏矩阵相加。代码中代码功能描述、输入输出说明和测试输出输入。
  • 三元组稀疏矩阵快速转置C语言算法

    千次阅读 2021-05-20 06:35:00
    三元组稀疏矩阵快速转置C语言算法徐光联摘要:三元组稀疏矩阵的快速转置算法在《数据结构》课程中是一个难点,这里给出三元组稀疏矩阵的转置算法详细讲解,并给出C语言算法的源程序。关键词:三元组;稀疏矩阵;...
  • C语言数据结构 两种算法实现 稀疏矩阵 转置

    千次阅读 多人点赞 2018-11-24 11:33:48
    普通算法实现稀疏矩阵转置(思路看代码注释) /*C语言数据结构 *普通算法实现稀疏矩阵装置 */ /*测试数据:mu:6 nu:6 tu:8 矩阵如下: 0 12 9 0 0 0 0 0 0 0 0 0 -3 0 0 0 0 14 0 0 24 0 0 0 0 18 0...
  • 数据结构——稀疏矩阵C语言

    千次阅读 2021-09-03 16:17:48
    矩阵什么是矩阵代码实现三元组以及普通转置矩阵以及三元组的结构体相应功能的函数实现初始化稀疏矩阵矩阵转置链表数据的删除按位置查找数据元素合并两个链表输出链表相应功能集成调用主函数运行截图 什么是矩阵 ...
  • 本题要求使用三元组进行矩阵转置,方法有两种,列序递增转置以及一次定位快速转置。 第一种方法思路简单,即将行列直接交换再进行排列,但占用空间较多,时间较慢。 第二种方法耗时较短,思路简述为记录每一列元素个...
  • 图4手写体签名【问题】请将以下稀疏点阵信息用三元组表进行存储,并:****************************(1)用稀疏矩阵快速转置法对该矩阵进行转置转置前后的三元组表均以行序为主序。(2)以阵列形式输出转置前后的稀疏...
  • 西工大NOJ数据结构实验——2.1稀疏矩阵转置

    千次阅读 多人点赞 2022-04-01 13:57:27
    西工大NOJ数据结构实验——2.1稀疏矩阵转置
  • 稀疏矩阵转置的三个算法
  • 三元组顺序表表示的稀疏矩阵转置(10分) 本题要求实现一个函数,实现三元组顺序表表示的稀疏矩阵转置。 函数接口定义: struct tripletable * trans(struct tripletable *t1); 其中 t1 是用户传入的参数。 函数须...
  • 一个稀疏矩阵A的转置矩阵B,输入使用三元组输入,输出原三元组,原矩阵,转置后三元组,转置后矩阵
  • 稀疏矩阵转置的c程序实现:稀疏矩阵的大部分元素为0,该程序不保存元素0,节省了运行空间
  • C语言实现稀疏矩阵转置,采用数组的形式存储数据,构建稀疏矩阵
  • 稀疏矩阵的快速转置C语言版)

    万次阅读 2015-11-30 21:10:34
     printf("稀疏矩阵为:\n\n");  int i,j,k,s,r,t;  for(i=0;i;i++)  for(k=0;k;k++)  m[i][k]=0; /*初始化为0*/  for(i=1;i[0].v;i++){  s=a[i].i;r=a[i].j;t=a[i].v;  m[s-1][r-1]=t; /*填入...
  • 6-42 稀疏矩阵转置

    2021-12-02 15:18:49
    本题求稀疏矩阵转置。 函数接口定义: void trans_mat(elem a[],int n,elem b[]); 其中b表示稀疏矩阵a的转置矩阵。 裁判测试程序样例: #include <stdio.h> #define N 5 //二维数组的行列值 #define ...
  • 6-2 三元组顺序表表示的稀疏矩阵转置 (10 分) 本题要求实现一个函数,实现三元组顺序表表示的稀疏矩阵转置。 函数接口定义: struct tripletable * trans(struct tripletable *t1); 其中 t1 是用户传入的参数。 函数...
  • 稀疏矩阵转置 需要经历以下 3 步: 将矩阵的行数和列数互换; 将三元组表(存储矩阵)中的 i 列和 j 列互换,实现矩阵的转置; 以 j 列为序,重新排列三元组表中存储各三元组的先后顺序; 稀疏矩阵快速转置算法...
  • 数据结构,该程序是利用c语言实现稀疏矩阵的三元组转置算法
  • 稀疏矩阵转置以及输出

    千次阅读 2020-12-06 09:52:32
    稀疏矩阵转置以及输出 代码实现: 1.稀疏矩阵的输入 2.稀疏矩阵转三元组 3.转置 4.三元组转稀疏矩阵 #include<iostream.h> #include<stdio.h> #define MAXSIZE 10000 typedef int ElemType; typedef int...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 767
精华内容 306
关键字:

稀疏矩阵的转置c语言