百花2022年计算机类数据结构作业6

最新推荐文章于 2023-10-21 22:16:13 发布
最新推荐文章于 2023-10-21 22:16:13 发布
阅读量717 收藏 1
点赞数
分类专栏： 数据结构作业 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Qa666qa/article/details/127475142
版权

问题 A: 函数可变参数练习-附加代码模式

C和C++语言都支持在函数中使用数量不定的参数列表进行运算。本题使用附加代码模式，用一个简单的求和任务，让同学们练习可变参数的函数语法。
main函数代码如下，会自动附加在同学们提交的代码后面。

int main() {

    int result = sum(3, 1, 2, 3);

    printf("the result is %d\n", result);

    return 0;

}

answer

#include<bits/stdc++.h>
using namespace std;
int sum(int cnt,...){
    int sums=0;
    va_list ap;
    va_start(ap,cnt);
    for(int i=0;i<cnt;i++){
        int arg=va_arg(ap,int);
        sums+=arg;
    }
    va_end(ap);
    return sums;
}
/*int main()
{
    int t=sum(3,1,2,3);
    cout<<t;
    return 0;
}*/

问题 B: 多维下标向一维下标的换算

题目描述

多维数组的元素标识通常是用多维下标(i0, i1, i2, .., in-1)，而多维数组以顺序方式存储在内存中，内存的地址空间是一维的，要操作多维数组就需要计算从多维下标向一维下标的换算。

输入格式

输入的每一行为一个测试用例。
每一行由一组非负整数组成，第一个数是多维数组的维数n(2~11)，从第二个数开始的n个数是从高维到低维每一维的维长(1~20)，接着的n个数是一个n维下标。下标起始从0开始。

输出格式

对每一个测试样例，计算给定多维下标按行优向顺序对应的一维下标，并输出这个一维下标的值。每个测试样例输出一行。

#include<bits/stdc++.h>
using namespace std;
 
int main()
{
    int n;
    while(cin>>n){
        int a[105],b[105];
        //cin>>a[0];
        for(int i=0;i<n;i++){
            cin>>a[i];
            //if(i)
             //   a[i]+=a[i-1];
        }
        for(int i=0;i<n;i++){
            cin>>b[i];
            //if(i)
            //    b[i]+=b[i-1];
        }
        int sum=0;
        for(int i=0;i<n;i++){
            int t=b[i];
            for(int j=i+1;j<n;j++) t*=a[j];
            sum+=t;
        }
        cout<<sum<<endl;
    }
    return 0;
}

问题 C: 稀疏矩阵类型判断

题目描述

输入一个稀疏矩阵，输出其类型。类型包括：

上三角：对角线及其右上方的元素非0，其它元素为0

下三角：对角线及其左下方的元素非0，其它元素为0

对称：沿对角线对称的元素非0且相等

空矩阵：所有元素都为0

其它为普通矩阵

#include<bits/stdc++.h>
using namespace std;
int a[105][105];
int check(int m,int n){
    if(m==0&&n==0) return 0;
 
       bool f5=1;
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(a[i][j]){
                f5=0;
                break;
            } 
        }
    }
    if(f5) return 5;
    bool f1=1;
    for(int i=1;i<m;i++){
        for(int j=0;j<i;j++){
            if(a[i][j]){
                f1=0;
                break;
            } 
        }
    }
    if(f1) return 1;
    bool f2=1;
    for(int i=0;i<m-1;i++){
        for(int j=i+1;j<n;j++){
            if(a[i][j]){
                f2=0;
                break;
            } 
        }
    }
    if(f2) return 2;
    if(m==n){
        bool f3=1,f4=1;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if((i!=j&&a[i][j]==0)||(a[i][j]!=a[j][i])){
                    f3=0;
                    break;
                } 
            }
        }
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if((i!=j&&a[i][j]==0)||(a[i][j]!=a[n+1-j][n+1-i])){
                    f4=0;
                    break;
                } 
            }
        }
        if(f3||f4)
            return 3;
    }
  
    return 6;
}
int main()
{
    int m,n;
    while(cin>>m>>n){
        for(int i=0;i<m;i++)
        for(int j=0;j<n;j++) cin>>a[i][j];
        if(m!=n) cout<<"putong"<<endl;
        else{
            int t=check(m,n);
            if(t==1) cout<<"shangsanjiao"<<endl;
            else if(t==2) cout<<"xiasanjiao"<<endl;
            else if(t==3) cout<<"duichen"<<endl;
            else if(t==5) cout<<"kong"<<endl;
            else cout<<"putong"<<endl;
        }
    }
 
    return 0;
}

问题 D: 稀疏矩阵转换成简记形式-附加代码模式

大部分元素是0的矩阵称为稀疏矩阵，假设有k个非0元素，则可把稀疏矩阵用k*3的矩阵简记之，其中第一列是行号，第二列是列号，第三列是该行、该列下的非元素的值。如：
0 0 0 5
0 2 0 0
0 1 0 0
可以简记成：
1 4 5
2 2 2
3 2 1
试编程读入一稀疏矩阵，转换成简记形式，并输出。

不会，直接改函数-_-|||

#include<bits/stdc++.h>
using namespace std;
//#define vector<int> TriTable
typedef vector<int> TriTable;
/*struct TriNode{
    int row,col;
    int data;
};
 
struct TriTable{
    TriNode *datas;
    int mu,nu,tu;
};*/
vector<int> q;
void CreateTriTable(TriTable &T,int maxtrix[],int m,int n){
    /*T.mu=m,T.nu=n;int num=0;
    for(int i=0;i<m*n;i++)
        if(maxtrix[i]){
            T.datas[num].row=i/m;
            T.datas[num].col=i%n;
            T.datas[num].data=maxtrix[i];
            num++;
        }
    T.tu=num;*/
    for(int i=0;i<m*n;i++)
        T.push_back(maxtrix[i]);    
    q.push_back(m);
    q.push_back(n);    
}
int DestroyTriTable(TriTable &t){
    return 0;
}
void PrintTriTable(TriTable &T){
    int k=0;
    int  m=q.back();q.pop_back();
    int n=q.back();
    for(auto i:T){
        if(i!=0)
            cout<<k/m+1<<" "<<k%m+1<<" "<<i<<endl;
        k++;    
    }
}
/*int main()
{
    int *maxtrix,m,n;
    cin>>m>>n;
    maxtrix=new int[n*m];
    for(int i=0;i<m*n;i++) cin>>maxtrix[i];
    TriTable T;
    CreateTriTable(T,maxtrix,m,n);
    PrintTriTable(T);
    DestroyTriTable(T);
    delete []maxtrix;
    return 0;
}*/

问题 E: 根据三元组输出稀疏矩阵

题目描述

给定三元组表示的稀疏矩阵，输出对应的矩阵

输入格式

输入包括一组测试数据，对应三元组表示的稀疏矩阵。
第一行为矩阵行数m，第二行为矩阵列数n，第三行为非零元个数t。 m，n都为小于100的正整数，t为小于10000的非负整数。
接下来t行为t个非零元的行、列、值，都是整数

输出格式

输出对应的稀疏矩阵

输入样例 复制

m=3
n=2
t=1
1 1 5

输出样例 复制

0 0
0 5
0 0

 输入坑了点.

#include<bits/stdc++.h>
using namespace std;
int a[105][105]={0};
int main()
{
    int m,n,t;
    int b[5]={0};
    for(int i=0;i<3;i++){
        string s;
        cin>>s;
        for(int j=2;j<s.length();j++)
            b[i]=b[i]*10+int(s[j]-'0');
    }
    //for(int i=0;i<3;i++) cout<<b[i]<<endl;
    m=b[0],n=b[1],t=b[2];
    for(int i=0;i<t;i++){
        int x,y,z;
        cin>>x>>y>>z;
        a[x][y]=z;
    }
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++) cout<<a[i][j]<<" ";
        cout<<endl;
    }
    return 0;
}

问题 F: 三元组法表示的稀疏矩阵，计算每行非零元个数，行索引，每列非零元个数，列索引

题目描述

给定一个三元组法表示的稀疏矩阵，计算每行非零元个数，行索引，每列非零元个数，列索引并输出。其中行索引，指的是该行起始位置在稀疏矩阵的值向量中的索引，同理，列索引，指的是该列起始位置在稀疏矩阵的值向量中的索引。

输入格式

输入第一行为稀疏矩阵的行数mu，第二行为稀疏矩阵的列数nu，第三行为稀疏矩阵的非零元个数tu，其中mu，nu，tu都是小于100的正整数
接下来tu行，每行包括空格分隔的3个整数，分别代表每个非零元的行、列、值。

输出格式

输出四个向量，分别是每行非零元个数，行索引，每列非零元个数，列索引。

输入样例 复制

5
6
7
0 1 2
0 4 5
1 3 7
2 3 11
2 4 5
2 5 2
4 4 8

输出样例 复制

rowSum: 2 1 3 0 1
rowPos: 0 2 3 6 6
colSum: 0 1 0 2 3 1
colPos: 0 0 1 1 3 6

 

#include<bits/stdc++.h>
using namespace std;
int a[105][105]={0};
int row[105]={0},col[105]={0};
int rowpos[105]={0},colpos[105]={0};
int main()
{
    int m,n,t;
    cin>>m>>n>>t;
    for(int i=0;i<t;i++){
        int x,y,z;
        cin>>x>>y>>z;
        a[x][y]=z;
    }
    /*for(int i=0;i<m;i++){
        for(int j=0;j<n;j++) cout<<a[i][j]<<" ";
        cout<<endl;
    }*/
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++){
            if(a[i][j]) row[i]++;
        }
    }
    for(int j=0;j<n;j++){
        for(int i=0;i<m;i++){
            if(a[i][j]) col[j]++;
        }
    }
    cout<<"rowSum: ";
    for(int i=0;i<m;i++) cout<<row[i]<<" ";
    cout<<endl;
    cout<<"rowPos: 0 ";
    for(int i=1;i<m;i++){
         
        cout<<row[i-1]<<" ";
        row[i]+=row[i-1];
    }
    cout<<endl;
 
 
    cout<<"colSum: ";
    for(int i=0;i<n;i++) cout<<col[i]<<" ";
    cout<<endl;
    cout<<"colPos: 0 ";
    for(int i=1;i<n;i++){
        cout<<col[i-1]<<" ";
        col[i]+=col[i-1];
    }
    return 0;
}

问题 G: 算法5-1：稀疏矩阵转置

稀疏矩阵的存储不宜用二维数组存储每个元素，那样的话会浪费很多的存储空间。所以可以使用一个一维数组存储其中的非零元素。这个一维数组的元素类型是一个三元组，由非零元素在该稀疏矩阵中的位置（行号和列号对）以及该元组的值构成。矩阵转置就是将矩阵行和列上的元素对换。

#include<bits/stdc++.h>
using namespace std;
int a[1005][1005]={0};
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++) cin>>a[i][j];
    for(int j=0;j<m;j++){
        for(int i=0;i<n;i++)
            cout<<a[i][j]<<" ";
        cout<<endl;    
    }
 
    return 0;
}

问题 H: 算法5-2：稀疏矩阵快速转置

稀疏矩阵的存储不宜用二维数组存储每个元素，那样的话会浪费很多的存储空间。所以可以使用一个一维数组存储其中的非零元素。这个一维数组的元素类型是一个三元组，由非零元素在该稀疏矩阵中的位置（行号和列号对）以及该元组的值构成。

而矩阵转置就是将矩阵行和列上的元素对换。参考算法5.1中的具体做法，令mu和nu分别代表稀疏矩阵的行数和列数，不难发现其时间复杂度为O(mu×nu)。而当非零元的个数tu与mu×nu同数量级时，算法5.1的时间复杂度将上升至O(mu×nu2)。因此，需要采用快速的稀疏矩阵转置算法。

不会，直接简单粗暴。

#include<bits/stdc++.h>
using namespace std;
int a[1005][1005]={0};
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++) cin>>a[i][j];
    for(int j=0;j<m;j++){
        for(int i=0;i<n;i++)
            cout<<a[i][j]<<" ";
        cout<<endl;    
    }
 
    return 0;
}

问题 I: 算法5-3：行逻辑链接的矩阵乘法

请使用行逻辑链接的顺序表实现两个稀疏矩阵的乘法。

不会，还是简单粗暴法。

#include<bits/stdc++.h>
using namespace std;
int a[1005][1005]={0};
int b[1005][1005]={0};
int main()
{
    int n,m;
    cin>>n>>m;
    for(int i=0;i<n;i++)
        for(int j=0;j<m;j++) cin>>a[i][j];
    int k;
    cin>>m>>k;
    for(int i=0;i<m;i++)
        for(int j=0;j<k;j++) cin>>b[i][j];
    for(int i=0;i<n;i++){
        for(int j=0;j<k;j++){
            int s=0;
            for(int t=0;t<m;t++){
                s+=a[i][t]*b[t][j];
            }
            cout<<s<<" ";
        }
        cout<<endl;
    }    
    return 0;
}

MATLAB算法实战应用案例精讲-【人工智能】AIGC概念三部曲（二）
qq_36130719的博客
04-09 758
人工智能生成内容（Artificial Intelligence Generated Content，简称AIGC）是一种利用人工智能技术自动生成文章、音频、视频等多媒体内容的方法。近年来，随着人工智能技术的不断发展和应用，越来越多的机构和公司开始尝试使用AIGC来快速且低成本地生成大量的内容，从而满足不同领域的需求。AIGC的发展离不开深度学习技术的支持。在过去的几年中，深度学习技术已经取得了重大进展，特别是在自然语言处理领域。
【数据结构】第七周
heliotrope_jin的博客
05-30 1227
第一排为分别为A、B元素的个数，以下各排分别输入对应的三元组，头m组为A中的元素，接下来为B的元素，同一个矩阵的元素按照行递增排列，第一行规定为1，同一行的元素按照列递增排列，第一列规定为1。【问题描述】这是一道2013年考研真题，已知一个整数序列A长度为N，其中若存在a，且a的个数大于N/2，则称a为A的主元素。【问题描述】将一个数组中的元素循环右移K位，要求只使用一个元素大小的附加存储空间，时间复杂度为O(n)。输入为9X9的二维数组，每个数字均为0-9之间的数字，其中0表示该位置的数字为未知。
2023年计科+AI数据结构平时作业-6
最新发布
weixin_73558212的博客
10-21 1260
多维数组的元素标识通常是用多维下标(i0, i1, i2, .., in-1)，而多维数组以顺序方式存储在内存中，内存的地址空间是一维的，要操作多维数组就需要计算从多维下标向一维下标的换算。输入的每一行为一个测试用例。每一行由一组非负整数组成，第一个数是多维数组的维数n(2~11)，从第二个数开始的n个数是从高维到低维每一维的维长(1~20)，接着的n个数是一个n维下标。下标起始从0开始。对每一个测试样例，计算给定多维下标按行优向顺序对应的一维下标，并输出这个一维下标的值。每个测试样例输出一行。65。
多维下标向一维下标的换算
Green_Jerry的博客
10-21 306
多维下标向一维下标的换算
北京化工大学数据结构2022/10/20作业 题解
m0_61735576的博客
10-20 1815
今天的题大家写着体验应该还好没啥好说的，基本全是暴力模拟。
Problem H: 稀疏矩阵的表示和运算
Usher_Ou的博客
05-04 2686
Problem H: 稀疏矩阵的表示和运算 Time Limit: 1 Sec  Memory Limit: 128 MB Submit: 155  Solved: 49 [Submit][Status][Web Board] Description 如果一个矩阵中，0元素占据了矩阵的大部分，那么这个矩阵称为“稀疏矩阵”。对于稀疏矩阵，传统的二维数组存储方式，会使用大量的内存来存
稀疏矩阵
baidu_36583119的博客
10-06 430
（1）如果一个矩阵的元素绝大部分为零，则称为稀疏矩阵。 （2）若直接使用一个二维数组表示稀疏矩阵，则会因为存储太多的零元素而浪费大量的内存空间。因此，通常采用三元组数组或十字链表两种方法来存储稀疏矩阵。 （3）三元组数组 稀疏矩阵的每个非零元素用一个三元组来表示，即非零元素的行号、列号和它的值。然后按照某种顺序将全部非零元素的三元组存于一个数组中。 （4）十字链表 ...
稀疏矩阵 C/C++
GoWilli的优快云
10-21 3712
稀疏矩阵的三元组存储、输入、输出、转置
VC++2012编程演练数据结构《17》稀疏矩阵
weixin_30745553的博客
11-20 92
如果在矩阵中，多数的元素为0，称此矩阵为稀疏矩阵（sparse matrix）。由于矩阵在程序中常使用二维阵列表示，二维阵列的大小 稀疏矩阵与使用的存储器空间成正比，如果多数的元素没有数据，则会造成存储器空间的浪费，为此，必须设计稀疏矩阵的阵列储存方式，利用较少的存储器空间储存完整的矩阵数据。　　二维数组Amn中有N个非零元素，若N<<m*n（N/m*n<=0.2),则称A...
稀疏矩阵的压缩与还原
qq_45771848的博客
11-25 2560
什么是稀疏矩阵？ 一个矩阵中，如果大部分元素都是0，只有少部分是非0元素，这个矩阵就叫做稀疏矩阵。如下图所示，下面这个矩阵只有第1行第2列和第2行第4列的元素不为空，这个矩阵就是一个稀疏矩阵。 通常，我们用二维数组表示矩阵，但我们用二维数组表示稀疏矩阵时，二维数组里会存大量的0元素，占用内存，极大的浪费空间。这个时候我们通常会对稀疏矩阵进行压缩，让二维数组只存储非0元素，如下图所示。 假设压缩后的二维数组为B，B的第0行用来存储稀疏矩阵的相关信息。如B[0][0]表示稀疏矩阵一共有多少行，B[0][1]表
利用十字链表压缩稀疏矩阵（c++）-- 数据结构
weixin_34343689的博客
04-11 1047
题目： 7-1 稀疏矩阵 （30 分) 如果一个矩阵中，0元素占据了矩阵的大部分，那么这个矩阵称为“稀疏矩阵”。对于稀疏矩阵，传统的二维数组存储方式，会使用大量的内存来存储0，从而浪费大量内存。为此，可以用三元组的方式来存放一个稀疏矩阵。 对于一个给定的稀疏矩阵，设第r行、第c列值为v，且v不等于0，则这个值可以表示为 <r,v,c>。这个表示方...
数据结构之稀疏矩阵转置
weixin_43700556的博客
04-12 2226
#include<stdio.h> #define MAXSIZE 10 typedef struct{ int row,col; int e; }Triple; typedef struct{ Triple data[MAXSIZE+1]; int m,n,len; }Matrix; void TranposeMatrix(Matrix A,Matri...
数组元素的地址计算问题（一维到高维）
热门推荐
斜阳雨陌
08-22 1万+
数组元素存储地址的计算 一维数组 设一维数组A[n]存放在n个连续的存储单元中，每个数组元素占一个存储单元（不妨设为C个连续字节）.如果数组元素A[0]的首地址是L，则A[1]的首地址是L+C，A[2]的首地址是L+2C，… …，依次类推，对于有：   二维数组 二维数组的每个元素含两个下标，如果将二维数组的第一个下标理解为行号，第二个下标理解为列号，然后按行列次序排列个元素，则二维数组
三元组稀疏矩阵的快速转置
wangxiaohigh
11-27 576
小问题却整了这么久，能力有待加强，要强烈区分三元组的列数与元素总数，不能将他俩写混了 #include&lt;stdio.h&gt; #define MAXSIZE 1250 #define OK 1 #define ERROR 0 #define TRUE 1 #define FLASE 0 typedef int Statu...
数组（稀疏矩阵）
lumaomao_的专栏
01-28 770
typedef struct { int i,j; int value; }Triple; typedef struct { Triple data[MAXSIZE]; int rpos[MAXRC]; int row,col,num; }XiShuArray; int triarray(XiShuArray &M) // 创建一个稀疏矩阵； // 输入行数、列数
第五章 5.51稀疏矩阵转置的第二种方法（快速转置法）
alovelypeach的博客
05-01 541
#include <iostream> #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR 0 #define MAXSIZE 12500 typedef int elemtype; typedef int status; typedef struct { int i,j; ...
稀疏矩阵转置中的快速转置
swordboy_fire的博客
09-27 301
稀疏矩阵转置中的快速转置就是记录目标矩阵每一行的开始位置，在对原始矩阵的每个元素进行转置时，只需根据元素的所在列和目标矩阵对应行的开始位置，就可确定目标元素的位置，进而进行原始元素和目标元素相应值得交换，具体c语言代码如下： #include&lt;iostream&gt; #define MAXSIZE 12500 typedef struct { int i, j; int e; ...
快速排序实现稀疏矩阵的转置
Christine的专栏
05-18 1063
突然感觉快排都不会写了，只是
电脑软件国画集锦：百花图谱欣赏
资源摘要信息: "电脑软件精美国画图集百花图谱.rar" 本资源为一款涉及电脑软件应用的国画图集压缩包，名为“电脑软件精美国画图集百花图谱”，它可能是一个集合了多种电脑软件制作的国画作品的电子图库。由于资源的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值