仲舟のMOOC第六周编程作业

最新推荐文章于 2024-08-29 16:08:24 发布
最新推荐文章于 2024-08-29 16:08:24 发布
阅读量277 收藏 1
点赞数 4
分类专栏： 作业 文章标签： 数据结构 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51602939/article/details/115921608
版权

仲舟：这是我的第一篇博客，因为慕课编程作业越来越离谱，很多人发上百行代码问我错哪，由于每个人思路不同我基本要花近一个小时解决，所以特意写了篇博客，以后比较难点的问题我都会写博客，尽量把我的思路解释清楚，希望能对大家有所帮助，同时也是对我的学习过程一个记录。

///*题目：实现稀疏矩阵（采用三元组表示法）的基本运算 
///*作者：仲舟                                       
///*难度：★★★★★
///*完成时间：2021.04.20
#include <stdio.h>
#define maxsize 100

typedef enum {false,true} bool;
typedef struct {
    int  data[100][100];  /*二维数组*/
    int  rows,cols;             /*行数和列数*/
} Matrix; //稀疏矩阵

typedef struct {
    int  row,col;  /*行号、列号*/
    int  item; /*非零元素值*/
} TupleNode; /*三元组的类型 */

typedef struct {
    TupleNode data[maxsize];
    int  rows,cols;  /*行数、列数*/
    int  nums; /*非零元个数*/
} TSMatrix; /*三元组顺序表的类型 */

void  Compressmatrix(Matrix A, TSMatrix *B);//产生稀疏矩阵A的三元组表示t
bool  Value(TSMatrix *t,int x,int i,int j);//将x赋值给三元组t中稀疏矩阵A的A[i][j]，并返回true，若i,j非法，返回false
bool  Assign(TSMatrix t,int *x,int i,int j); //取三元组t中稀疏矩阵A的A[i][j]的值赋给指针变量x所指变量，并返回true，若i,j非法，返回false
void  Print(TSMatrix B);  //输出三元组
void  Transpmatrix (TSMatrix B, TSMatrix *C);//求三元组表示B的转置矩阵（仍使用三元组表示）

/*添加函数*/
int OneDimensionValue(TSMatrix t,int i,int j);//计算三元组转化为一维组后所求矩阵距第一个下标之差
void Insert(TSMatrix *t,int i,int j,int x);//插入一个元素（0就不插）
void Delete(TSMatrix *t,int i,int j);//删除一个元素（值为0）
void swap(int *x,int *y);//交换

main() {
    int i,j,k,x,rows,cols,N;
    bool flag;
    Matrix A;
    TSMatrix B,C;
    scanf("%d%d",&rows,&cols);
    A.rows=rows;
    A.cols=cols;
    for ( i=0; i<rows; i++)
        for (j=0; j<cols; j++)
            scanf("%d",&A.data[i][j]);
    Compressmatrix(A,&B);
    Print(B);

    Transpmatrix (B, &C);
    printf("the transpose of this matrix\n");
    Print(C);
    scanf("%d",&N);
    for (k=0; k<N; k++) {
        scanf("%d%d",&i,&j);
        flag=Assign(B,&x,i,j);
        if (flag==true) {
            printf("A[%d,%d]=%d\n",i,j,x);
        } else {
            printf("A[%d,%d] is wrong\n",i,j);
        }
    }
    scanf("%d",&N);
    for (k=0; k<N; k++) {
        scanf("%d%d%d",&i,&j,&x);
        flag=Value(&B,x,i,j);
        if (flag==true) {
            printf("success\n");
        } else {
            printf("A[%d,%d] is wrong\n",i,j);
        }
        Print(B);
    }


}
void Print(TSMatrix B) {
    int i;
    printf("%5d%5d%5d",B.data[0].row,B.data[0].col,B.data[0].item);
    for ( i=1; i<B.nums;  i++) {
        printf("\n%5d%5d%5d",B.data[i].row,B.data[i].col,B.data[i].item);
    }
    printf("\n");

}
//你的代码写在这里 ，注意提交完整程序进行测试

void  Compressmatrix(Matrix A, TSMatrix *B) { //产生稀疏矩阵A的三元组表示t
    /*B的初始化*/
    B->nums=0;
    B->cols=A.cols;
    B->rows=A.rows;
    /*找非0矩阵转移*/
    for (int i=0; i<A.rows; i++)
        for (int j=0; j<A.cols; j++)
            if(A.data[i][j]!=0) {
                B->data[B->nums].item=A.data[i][j];
                B->data[B->nums].row=i;
                B->data[B->nums].col=j;
                B->nums++;
            }
}

bool  Value(TSMatrix *t,int x,int i,int j)//将x赋值给三元组t中稀疏矩阵A的A[i][j]，并返回true，若i,j非法，返回false
{
    if(i<0||i>=t->cols||j<=0||j>=t->rows)//如果非法
        return false;
    else { //如果合法
        /*开始查找*/
        int flag=0;//是否找到
        for(int k=0; !flag&&k<=t->nums-1; k++)
            if(t->data[k].row==i&&t->data[k].col==j) {//如果找到
                if(x==0)//如果x==0，要删除
                    Delate(t,i,j);//删除（i，j）的位置
                else { //如果x!=0,则修改
                    flag=1;
                    t->data[k].item=x;
                }
            }
        if(flag==0&&x!=0)//如果没找到(如果x=0就不用插入)
            Insert(t,i,j,x);//新建（i，j）的一个位置并令其值为x
        return true;
    }
}

void Insert(TSMatrix *t,int i,int j,int x) {
    /*查找插入位置*/
    int perrow=-1,percol=-1,row,col,pos,flag=0,now,past,find;//前者行列，当前行列，插入位置，是否找到区间,现在、过去、要找的一维值
    for(int k=0; !flag&& k<=t->nums-1; k++) {
        row=t->data[k].row;
        col=t->data[k].col;
        find=OneDimensionValue(*t,i,j);
        now=OneDimensionValue(*t,row,col);
        past=OneDimensionValue(*t,perrow,percol);
        if(find>past&&find<now ){ //如果所插入一位值大于前者小于后者，两者之间
            pos=k;
            flag=1;
        }
    }
    if(flag==0)//如果没找到区间，就加在最后一行
        pos=t->nums+1;
    /*元素后移*/
    for(int k=++t->nums; k>=pos+1; k--) {
        t->data[k].col=t->data[k-1].col;
        t->data[k].row=t->data[k-1].row;
        t->data[k].item=t->data[k-1].item;
    }
    /*插入元素*/
    t->data[pos].row=i;
    t->data[pos].col=j;
    t->data[pos].item=x;
}

void Delate(TSMatrix *t,int i,int j) {
    /*查找位置*/
    for(int k=0; k<=t->nums-1; k++) {
        if(t->data[k].row==i&&t->data[k].col==j) {//如果找到开始前移
            for(int m=k; m<=t->nums-2; m++) {
                t->data[m].col=t->data[m+1].col;
                t->data[m].row=t->data[m+1].row;
                t->data[m].item=t->data[m+1].item;
            }
            break;
        }
    }
    t->nums--;
}

int OneDimensionValue(TSMatrix t,int i,int j) {
    return i*t.rows+j;
}

bool  Assign(TSMatrix t,int *x,int i,int j) {
    if(i<0||i>=t.cols||j<=0||j>=t.rows)//如果非法
        return false;
    else { //如果合法
        int flag=0;//是否找到
        for(int k=0; !flag&&k<=t.nums-1; k++)
            if(t.data[k].row==i&&t.data[k].col==j) {//如果找到
                *x=t.data[k].item;
                flag=1;
            }
        if(flag==0)//如果没找到那就说明等于0
            *x=0;
        return true;
    }
}

void  Transpmatrix (TSMatrix B, TSMatrix *C) { //求三元组表示B的转置矩阵（仍使用三元组表示）
    /*C数组初始化*/
    C->cols=B.rows;
    C->rows=B.cols;
    C->nums=B.nums;
    /*B矩阵转置*/
    for(int i=0; i<=B.nums-1; i++)
        swap(&B.data[i].col,&B.data[i].row);
    /*插入排序*/
    int min,pos,pmin=-1,now;//一维最小值，最小值下标，已输入最小值，当前一维下标值
    for(int j=0; j<=B.nums-1; j++){
        min=1<<20;//min初始化最大值
        for(int i=0; i<=B.nums-1; i++) {
            now=OneDimensionValue(B,B.data[i].row,B.data[i].col);
            if(now<min&&now>pmin) {//找除去已经找的值的最小值
                min=now;
                pos=i;
            }
        }
        /*矩阵转移*/
        C->data[j].item=B.data[pos].item;
        C->data[j].row=B.data[pos].row;
        C->data[j].col=B.data[pos].col;
        pmin=min;//记录该最小一维值
    }
}

void swap(int *x,int *y) {
    int temp=0;
    temp=*x;
    *x=*y;
    *y=temp;
}

///*题目：实现稀疏矩阵（采用三元组表示法）的加法运算 
///*作者：仲舟                                       
///*难度：★★★
///*完成时间：2021.04.20
#include <stdio.h>
#include<stdlib.h>
#define maxsize 100

typedef enum {false,true} bool;
typedef struct {
    int  data[100][100];  /*二维数组*/
    int  rows,cols;             /*行数和列数*/
} Matrix;

typedef struct {
    int  row,col;  /*行号、列号*/
    int  item; /*非零元素值*/
} TupleNode; /*三元组的类型 */

typedef struct {
    TupleNode data[maxsize];
    int  rows,cols;  /*行数、列数*/
    int  nums; /*非零元个数*/
} TSMatrix; /*三元组顺序表的类型 */

TSMatrix * Compressmatrix(Matrix T);//产生稀疏矩阵A的三元组表示t
void  Print(TSMatrix B);  //输出三元组
bool  Addmatrix(TSMatrix A,TSMatrix B, TSMatrix *C);// 求C=A+B; 若A，B矩阵行数或者列数不等，返回false ,否则返回true

/*添加函数*/
int OneDimensionValue(TSMatrix t,int i,int j);//计算三元组转化为一维组后所求矩阵距第一个下标之差

main() {
    int i,j,k,x,rows,cols,N;
    bool flag;
    Matrix T;
    TSMatrix *A,*B,C;
    scanf("%d%d",&rows,&cols);
    T.rows=rows;
    T.cols=cols;
    for ( i=0; i<rows; i++)
        for (j=0; j<cols; j++)
            scanf("%d",&T.data[i][j]);
    A=Compressmatrix(T);
    scanf("%d%d",&rows,&cols);
    T.rows=rows;
    T.cols=cols;
    for ( i=0; i<rows; i++)
        for (j=0; j<cols; j++)
            scanf("%d",&T.data[i][j]);
    B=Compressmatrix(T);
    flag=Addmatrix(*A,*B, &C);
    if (flag==false) {
        printf("cannot Add\n");
    } else {
        printf("the result:\n");
        Print(C);
    }
}
void Print(TSMatrix B) {
    int i;
    printf("%5d%5d%5d",B.data[0].row,B.data[0].col,B.data[0].item);
    for ( i=1; i<B.nums;  i++) {
        printf("\n%5d%5d%5d",B.data[i].row,B.data[i].col,B.data[i].item);
    }
    printf("\n");

}

TSMatrix * Compressmatrix(Matrix T) { //产生稀疏矩阵A的三元组表示t
    /*B矩阵初始化*/
    TSMatrix *B;
    B=(TSMatrix*)malloc(sizeof(TSMatrix));
    B->nums=0;
    B->cols=T.cols;
    B->rows=T.rows;
    /*找非0矩阵转移*/
    for (int i=0; i<T.rows; i++)
        for (int j=0; j<T.cols; j++)
            if(T.data[i][j]!=0) {//是非0就读入
                B->data[B->nums].item=T.data[i][j];
                B->data[B->nums].row=i;
                B->data[B->nums].col=j;
                B->nums++;
            }
    return B;
}

bool  Addmatrix(TSMatrix A,TSMatrix B, TSMatrix *C) {
    if(A.cols!=B.cols||A.rows!=B.rows)//如果A和B两矩阵非法
        return false;
    else { //如果合法
        int anow,bnow,i,j;//A矩阵的当前一维值，B矩阵的当前一维值
        C->cols=A.cols;
        C->rows=A.rows;
        /*双指针对比找最小的一方给C，当有矩阵用完就退出*/
        for(i=0,j=0; i<=A.nums-1&&j<=B.nums-1;) {
            anow=OneDimensionValue(A,A.data[i].row,A.data[i].col);
            bnow=OneDimensionValue(B,B.data[j].row,B.data[j].col);
            if(anow>bnow) {
                C->data[C->nums].row=B.data[j].row;
                C->data[C->nums].col=B.data[j].col;
                C->data[C->nums].item=B.data[j].item;
                C->nums++;
                j++;//下一个B.data
            }
            if(anow==bnow) {
                if(A.data[i].item+B.data[j].item!=0) {//相加可能会产生值为0的情况，应舍去
                    C->data[C->nums].row=B.data[j].row;
                    C->data[C->nums].col=B.data[j].col;
                    C->data[C->nums].item=A.data[i].item+B.data[j].item;
                    C->nums++;
                }
                i++;
                j++;//因为两矩阵同位置相加，所以两边该位置元素同时消除
            }
            if(anow<bnow) {
                C->data[C->nums].row=A.data[i].row;
                C->data[C->nums].col=A.data[i].col;
                C->data[C->nums].item=A.data[i].item;
                C->nums++;
                i++;//下一个A.data
            }
        }
        /*把还存在元素的矩阵顺序放入C（下面循环正常情况下只会执行一个）*/
        for(; i<=A.nums-1; i++) {
            C->data[C->nums].row=A.data[i].row;
            C->data[C->nums].col=A.data[i].col;
            C->data[C->nums].item=A.data[i].item;
            C->nums++;
        }
        for(; j<=B.nums-1; j++) {
            C->data[C->nums].row=B.data[j].row;
            C->data[C->nums].col=B.data[j].col;
            C->data[C->nums].item=B.data[j].item;
            C->nums++;
        }
        return true;
    }
}

int OneDimensionValue(TSMatrix t,int i,int j) {
    return i*t.rows+j;
}

仲舟原创，未经允许禁止转载！

仲舟
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
江西师范大学字符串和数组（下）编程作业
m0_55770247的博客
04-21 593
前言：第二道完全是按照我自己思路写的，没按题目所给的函数写 不想吐槽题目了，感觉浪费了我半个小时去写它(提交c++，因为C语言在99标准之前没有Bool类型，他题目加了枚举类型，但我没加) 1. 实现稀疏矩阵（采用三元组表示法）的基本运算（30分） #include <stdio.h> #define maxsize 100 typedef enum {false,true} bool; typedef struct { int data[100][100]; /*二维数组*/
压缩矩阵
SAYA_的博客
11-05 949
根据数据结构书本上敲打的，讲述内容较少，但是添加了一些注释。 //稀疏矩阵的压缩存储,最多存储10*10的矩阵 #include #include//use setw using namespace std; typedef struct { int row;//非零元的行下标 int column;//非零元的列下标 int e;//非零元 }Triple; typedef str
实现稀疏矩阵(用三元组表示)的转置操作
MengHao的博客
12-02 3331
代码+注释才是最好懂的~  #include &lt;iostream&gt; #include &lt;cstdlib&gt; #include &lt;cstring&gt; #define N 4 #define MaxSize 1005 // 假设非零元个数最大为1005 using namespace std; typedef int ElemType; typedef ...
三元组快速转置矩阵
碳酸钙的01妖精的博客
06-20 1952
快速转置矩阵（三元组）#include&lt;stdio.h&gt;#include&lt;string.h&gt;#define MAXN 200typedef struct{int i,j;int elem;}triple;typedef struct{triple data[MAXN];int m,n,len;}triplematrix;int num[1000],cpot[10...
Sparse Matrix(稀疏矩阵三元组表示，三元组形式的矩阵转置)
学无止境，Fighting！
10-22 1086
#include typedef struct{ int data[100][100]; int m, n; }matrix; typedef int spmatrix[100][3]; void compressmatrix(matrix A, spmatrix B)//二维数组转为三元组表示 { int i, j, k = 1; for(i=0;i for(j=0;
程序设计入门——C语言 MOOC第7周编程练习
yinghualiu000的博客
04-13 1847
程序设计入门——C语言 MOOC第7周编程练习 1. 多项式加法（5分） 题目内容 一个多项式可以表达为x的各次幂与系数乘积的和，比如：2x6+3x5+12x3+6x+20现在，你的程序要读入两个多项式，然后输出这两个多项式的和，也就是把对应的幂上的系数相加然后输出。程序要处理的幂最大为100。 输入格式 总共要输入两个多项式，每个多项式的输入格式如下：每行输入两个数字，第一个表示幂次，第二个表示...
哈工大-C语言程序设计精髓-MOOC慕课-6-12周编程题答案.docx
07-19
### 哈工大-C语言程序设计精髓-MOOC慕课-6-12周编程题答案 #### 编程知识点解析 ##### 第6周题目分析与解答 **6.1 题目概述** 本题的目标是实现一个程序，该程序能够接收用户输入的成绩，并将其转换为五分制等级...
MOOC《Python语言程序设计》第六周测试题
12-21
MOOC《Python语言程序设计》第六周测试题 单项选择题 点击选项选择正确答案，每题有且仅有一个正确答案 1.序列s，哪个选项对s.index(x)的描述是正确的？‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪...
大连理工大学程序设计基础mooc第三章编程作业
12-02
大连理工大学程序设计基础mooc第三章编程作业主要是让学生练习使用C++编程语言进行简单的程序设计。通过本章的作业，学生需要掌握基本的输入输出、变量与数据类型、流程控制语句等基础知识，并且能够应用这些知识...
MOOC西安交通大学C++编程作业.rar_mental28b_noteqqi_servei4l_soldiereps_some
09-23
《西安交通大学MOOC C++编程作业详解》 在学习编程的过程中，C++是一门重要的语言，尤其对于初学者，理解并掌握其语法和编程思想至关重要。西安交通大学的MOOC课程提供了丰富的教学资源，其中包括C++编程作业，这些...
仲舟の原创算法——树与二叉树的相互转换
qq_51602939的博客
05-10 472
这是我有史以来做过最难的数据结构，没查找任何资料写的题目，我尽量备注清楚方便大家读懂。 ///*题目：树与二叉树的相互转换 ///*作者：仲舟 ///*难度：★★★★★★ ///*完成时间：2021.05.10 #include<stdio.h> #define M 3//树的度数 #define MAXSIZE 100//最大结点数 typedef struct bnode { /*二叉树结构定义*/ char data; struct bnode *lchild,*rchi
稀疏矩阵的转置（矩阵转置和快速转置）
热门推荐
zhao2018的博客
06-23 3万+
原理是：如果能预先确定矩阵M中每一列（即T中每一行）的第一个非零元在b.data中(上面那图是b.data)恰当位置。那么在对a.data中的三元组一次做转置时，便可直接放到b.data中恰当的位置上去。设两个向量：num和cpotnum[col]表示矩阵M中第col列中的非零元素个数。cpot[col]指M中第col列的第一个非零元在b.data中的恰当位置。有下面两个公式：cpot[0]=0;...
数据结构——顺序表
m0_61965705的博客
08-27 478
例如：查找顺序表中的某个元素所在下标，就可以使用ForeachSeqList函数，搭配FindData函数传参对遍历到的数据进行操作。如果要存放字符串类型的，最好写成以下形式。空间可以不连续，访问元素方便。
Java-数据结构-包装类和认识泛型 !!!∑(ﾟДﾟノ)ノ
2303_80388948的博客
08-27 1157
对于泛型就是：使用与许多许多类型。从代码上来说呢，就是对类型实现了参数化。对于引出泛型，我们来实现一个类，类中包含一个数组成员，使得数组中可以存放任何类型的数据，也可以根据成员方法返回数组中某个下标的值。在这里呢，我们用 Object类 来进行创建数组，Object是所有类的父类，但是呢，我们在这里呢就有一些问题，我们来看看：1、在这里呢，我们这个数组当中可以存放任何类型2、我们每次进行的到值时候呢，都要进行强转。
数据结构—链表
2301_79909332的博客
08-27 730
数据量增长与程序运行时间的比例关系以函数描述称为时间渐进复杂度函数,简称时间复杂度。数据量增长与程序所占用空间的比例关系称为空间复杂度。顺序表、链式表、顺序栈、链式栈、顺序队列、链式队列 、树 二叉树。使用该函数遍历顺序表内元素，符合条件的可对其进行计数和打印。使用该函数遍历顺序表内元素，符合条件的对其进行修改。3.链表空间不连续,使得理论上长度是无限的。2.链表需要更大的空间存放数据和节点地址。1.空间可以不连续，访问元素不方便。3.程序 = 数据结构 + 算法。4.链表的插入和删除效率很高。
数据结构（邓俊辉）学习笔记】串 05——KMP算法：理解next[]表
weixin_44399845的博客
08-26 1336
KMP算法：理解next[]表
集合及数据结构第十三节（下）———— 枚举与Lambda表达式
2301_79418684的博客
08-27 1165
枚举与枚举的使用 1. 什么是C语言 2. 数据类型 3. 变量、常量 4. 字符串+转义字符+注释 5. 选择语句 6. 循环语句 7. 函数 8. 数组 9. 操作符 10. 常见关键字 11. define 定义常量和宏 12. 指针 13. 结构体
Java算法之插入排序（Insertion Sort）
最新发布
weixin_38959316的博客
08-29 168
插入排序是一种简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。这个过程像打牌时整理手中的牌一样，逐步将数据排列成有序。插入排序虽然在实际应用中的效率不如一些更高级的排序算法，但它的原理简单，易于实现，且对于部分有序的数据集表现良好。
数据结构（邓俊辉）学习笔记】串 06——KMP算法：构造next[]表
weixin_44399845的博客
08-27 724
KMP算法：构造next[]表
大连理工大学moocc语言第四周编程作业
10-03
大连理工大学的moocc语言第四周编程作业主要涉及以下内容。在这个作业中，学生需要运用所学的编程知识，完成一系列任务。 首先，学生需要设计一个程序，实现从一堆数字中找出最大和最小值的功能。这要求学生熟悉...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值