利用稀疏矩阵的顺序存储实现稀疏矩阵的加、减、乘、转置等简单运算。 这是课题要求，求大佬用c语言。

内容
假设两个稀疏矩阵A和B，他们均为m行n列，要求表写求矩阵的加法即：C=A+B的算法（C矩阵存储A与B相加的结果）
分析
利用一维数组来存储，一维数组顺序存放非零元素的行号、列号和数值，行号-1表示结束，然后进行矩阵加法运算时依次扫描矩阵A和B的行列值，并以行优先。当行列相同的时候，将第三个元素的值相加和以及行列号三个元素存入结果数组C中；不相同时，将A或B的三个元素直接存入结果数组中。
代码
// fanchencpp : 定义控制台应用程序的入口点。 // #include "stdafxh" #include<iostream> using namespace std; #define LINE 10 struct Node{ //行号 int row; //列号 int line; //数据 int data; }; //初始化数组 int init(Node array[]) { int row,line,data; int index = 0; while(cin>>row){ if(row == -1){ break; } cin>>line>>data; array[index]data=data; array[index]line = line; array[index]row = row; index++; } return index; } //打印数组 void printArray(Node array[],int len) { for(int i = 0;i < len;i++){ cout<<array[i]row<<" "<<array[i]line<<" "<<array[i]data<<endl; } } int calc(Node a

根据以下描述编写一个程序，使其能完成对稀疏矩阵的压缩与还原，即给定稀疏矩阵可以压缩存储一个三元组，并且能根据这个三元组能还原这个稀疏矩阵。
一个矩阵含有非零元素比较少，而零元素相对较多，这样的矩阵称为稀疏矩阵，对稀疏矩阵的存储我们不用完全的二维数组来存储，可以用一个三元组，即任意一个稀疏矩阵可以用一个只有三列的二维数组来存放，如图所示（已上传）
数据结构是一门涉及多门课程的课程，难度较大，需要较好的C语言的程序设计和调试能力，如果学生能够按照要求，从时间和精力上保证完全的投入，相信能够有很大的收获，几分投入几分收获，努力吧，同学们，不在此时更待何时！
要求是这样的：
1、用c语言编写一个简单的学生信息管理程序，能实现对学生信息的简单管理。
2、具体要求：
建立一个4个学生的信息登记表，每个学生的信息包括：学号，姓名，和3门课程的成绩（FOX,C,ENGLISH）。
程序运行时显示一个简单的菜单，例如：
（1）：信息输入（INPUT）
（2）：总分统计（COUNT）
（3）：总分排序（SORT）
（4）：查询(QUERY）
其中：
（1）：对4个学生的信息进行输入；
（2）：对每个学生的3门课程统计总分；
(3)：对4个学生的总分按降序排序并显示出来；
(4)：查询输入一个学号后，显示出该学生的有关信息；
游戏规则：
a，一个四位数，各位上的数字不重复,从1到9。
b，按以下提示猜出这个四位数。
c，每次猜测输入的数据给出类似的提示AB。
d，其中A前的代表你本次猜对了多少个数字。
e，其中B前的代表你本次猜对的数字并且位置正确的个数。
(6)计算平衡的二叉排序树BT的平均查找长度，输出结果。
1）输入任一年将显示出该年的所有月份日期，对应的星期
其显示格式要求如下：
其 Compress[][3]这个称为三元组，他是一个含有多行的只有三列的矩阵，其中第0行数据分别表示该稀疏矩阵的行数，列数和非零元素个数。以后每行表示一个非零元素的行数，列数和非零元素值，如：第3行中的2，4，4代表稀疏矩阵中的非零元素4在第2行，第4列，其值是4。

我刚写了一个稀疏矩阵的代码，如下
#include <iostream>
#include <iomanip>
using namespace std;
template<class T>
//三元组
struct Trituple
{
int row;
int col;
T val;
};
//稀疏矩阵声明
template<class T>
class SparseMatrix
{
public:
SparseMatrix(int maxt=100);
~SparseMatrix();
bool TransposeTo(SparseMatrix &);
bool AddTo(const SparseMatrix&);
bool TransposeTo_Faster(SparseMatrix&);
void Input();
void Output();
private:
Trituple<T> data;
int rows,cols,terms;
int maxterms;
};
template<class T>
SparseMatrix<T>::SparseMatrix(int maxt)
{
maxterms=maxt;
data=new Trituple<T>[maxterms];
terms=rows=cols=0;
}
template<class T>
SparseMatrix<T>::~SparseMatrix()
{
if (data!=NULL)
{
delete[] data;
}
}
//普通转置
template<class T>
bool SparseMatrix<T>::TransposeTo(SparseMatrix &B)
{
if (terms>Bmaxterms)
{
return false;
}
Brows=cols;
Bcols=rows;
Bterms=terms;
if (terms>0)
{
int p=0;
for (int j=1;j<=cols;j++)
{
for (int k=0;k<terms;k++)
{
if (data[k]col==j)
{
Bdata[p]row=j;
Bdata[p]col=data[k]row;
Bdata[p]val=data[k]val;
p++;
}
}
}
}
return true;
}
//快速转置
template<class T>
bool SparseMatrix<T>::TransposeTo_Faster(SparseMatrix& B)
{
if (terms>Bmaxterms)
{
return false;
}
Brows=cols;
Bcols=rows;
Bterms=terms;
if (terms>0)
{
int num,cpot;
num=new int[cols];
cpot=new int[cols];
for (int j=0;j<cols;j++)
{
num[j]=0;
}
for (int k=0;k<terms;k++)
{
num[data[k]col-1]++;
}
//求出B中每一行的起始下标cpot[]
cpot[0]=0;
for (int j=1;j<cols;j++)
{
cpot[j]=cpot[j-1]+num[j-1];
}
//执行转置 *** 作
for (int p,k=0;k<terms;k++)
{
p=cpot[data[k]col-1]++;
Bdata[p]row=data[k]col;
Bdata[p]col=data[k]row;
Bdata[p]val=data[k]val;
}
delete[] num;
delete[] cpot;
}
return true;
}
template<class T>
void SparseMatrix<T>::Input()
{
cout<<"intput the matrix' row:";
int row1;
cin>>row1;
cout<<"intput the matrix' col:";
int col1;
cin>>col1;
cout<<"input "<<row1<<""<<col1<<" matrix"<<endl;
int number;
rows=row1;
cols=col1;
for (int i=0;i<rows;i++)
{
for (int j=0;j<cols;j++)
{
cin>>number;
if (number!=0)
{
data[terms]row=i+1;
data[terms]col=j+1;
data[terms]val=number;
terms++;
}
}
}
}
template<class T> //输出好看，但是违背了最初的原则
void SparseMatrix<T>::Output()
{
T tempArray=new T[rows];
for (int i1=0;i1<rows;i1++)
{
tempArray[i1]=new int[cols];
}
for (int j=0;j<rows;j++)
{
for (int k=0;k<cols;k++)
{
tempArray[j][k]=0;
}
}
for (int i=0;i<terms;i++)
{
tempArray[data[i]row-1][data[i]col-1]=data[i]val;
}
for (int j=0;j<rows;j++)
{
for (int k=0;k<cols;k++)
{
cout<<setw(4)<<tempArray[j][k];
}
cout<<endl;
}
for (int l=0;l<rows;l++)
{
delete[] tempArray[l];
}
delete tempArray;
cout<<endl;
}
template<class T>
bool SparseMatrix<T>::AddTo(const SparseMatrix& B)
{
if (rows!=Brows||cols!=Bcols)
{
return false;
}
bool flag=false;
int tempTerms=terms;
for (int i=0;i<Bterms;i++)
{
flag=false;
for (int j=0;j<tempTerms;j++)
{
if (data[j]col==Bdata[i]col&&data[j]row==Bdata[i]row)
{
data[j]val+=Bdata[i]val;
flag=true;
}
}
if (flag==false)
{
data[++terms-1]col=Bdata[i]col; //数组下标 *** 作注意事项
data[terms-1]row=Bdata[i]row;
data[terms-1]val=Bdata[i]val;
}
}
return true;
}
int main()
{
cout<<"此程序演示稀疏矩阵的普通转置和快速转置 *** 作"<<endl;
SparseMatrix<int> sm(50);
SparseMatrix<int> sm1(50);
SparseMatrix<int> sm2(50);
smInput();
cout<<"sm is"<<endl;
smOutput();
smTransposeTo(sm1);
cout<<"Transposition of sm is "<<endl;
sm1Output();
smTransposeTo_Faster(sm2);
cout<<"Transposition of sm is "<<endl;
sm2Output();
SparseMatrix<int> sm3;
cout<<"input a new matrix"<<endl;
sm3Input();
cout<<"sm3 is"<<endl;
sm3Output();
if(smAddTo(sm3))
{
cout<<"after adding sm3 ,sm is"<<endl;
smOutput();
}
else
cout<<"the two matrix can't add"<<endl;
cout<<"Good job!"<<endl;
system("pause");
return 0;
}

---