测试: demo.cpp
#include "trituple.h" #include <iostream> using namespace std; int main(){ Trituple data1; Trituple data2; cout << "功能演示==========================================" << endl; cout << "功能1:输入已压缩的稀疏矩阵,转换成稀疏矩阵原形===== " << endl; TriSeqMatrix Ts = data1.input(); //输入已压缩 cout << "稀疏矩阵原形: " << endl; data1.output_p(Ts); //输出原形 cout << " ==================================================" << endl; cout << "功能2:输入稀疏矩阵原形,转换成压缩稀疏矩阵========= " << endl; TriSeqMatrix Ts2 = data2.input_p(); data2.output(Ts2); cout << " ==================================================" << endl; cout << "功能3:将稀疏矩阵转置==============================" << endl; cout << "转置功能1的稀疏矩阵=============================== " << endl; data1.transposition(Ts); cout << " 转置功能2的稀疏矩阵=============================== " << endl; data2.transposition(Ts2); cout << " ==================================================" << endl; cout << "功能4:将稀疏矩阵1 和 2相加======================== " << endl; data1.add(Ts, Ts2); cout << " ==================================================" << endl; cout << "功能5:将稀疏矩阵1 和 2相乘======================== " << endl; data1.multiply(Ts, Ts2); return 0; }
类头文件 : trituple.h
#define MAXSIZE 200 typedef int DataType; typedef struct{ int i,j; DataType e; }Trituple_s; typedef struct{ Trituple_s data[MAXSIZE]; int m, n, len; //行数, 列数, 长度 }TriSeqMatrix; class Trituple{ public: void transposition(TriSeqMatrix Ts); //转置 void add(TriSeqMatrix Ts, TriSeqMatrix Ts2); //相加 void multiply(TriSeqMatrix Ts, TriSeqMatrix Ts2); //相乘 TriSeqMatrix input(); //输入 TriSeqMatrix input_p(); //输入原始 void output_p(TriSeqMatrix Ts); //输出原形 void output(TriSeqMatrix Ts); //输出压缩 private: Trituple_s Tt; TriSeqMatrix Ts; };
输入压缩矩阵: input.cpp
#include <iostream> #include "trituple.h" using namespace std; TriSeqMatrix Trituple::input(){ cout << "请输入稀疏矩阵的行数, 列数, 非零元素个数: "; cin >> Ts.m >> Ts.n >> Ts.len; int i = 0; int k = 0; //记录元素 while (i < Ts.len){ cout << "请输入稀疏矩阵的非零元素,分别输入行,列, 和值: "; cin >> Tt.i >> Tt.j >> Tt.e; if (Tt.i >= Ts.m || Tt.j >= Ts.n){ cout << "输入的值超出了范围!请重新输入!" << endl; continue; } else{ Ts.data[k].i = Tt.i; Ts.data[k].j = Tt.j; Ts.data[k].e = Tt.e; k++; } i++; } return Ts; }
输入稀疏矩阵原形: input_p.cpp
#include <iostream> using namespace std; #include "trituple.h" TriSeqMatrix Trituple::input_p(){ cout << "请输入稀疏矩阵的行数, 列数, 非零元素个数: "; cin >> Ts.m >> Ts.n >> Ts.len; cout << "请规范输入稀疏矩阵: " << endl; int k_temp = 0; DataType indata; //用来接受输入 for (int i = 0; i < Ts.m; i++){ for (int j = 0; j < Ts.n; j++){ cin >> indata; if (indata != 0){ Ts.data[k_temp].i = i; Ts.data[k_temp].j = j; Ts.data[k_temp].e = indata; k_temp++; } } } return Ts; }
输出压缩矩阵: output.cpp
#include <iostream> using namespace std; #include "trituple.h" void Trituple::output(TriSeqMatrix Ts){ cout << "稀疏矩阵原形压缩后为(行,列,值): "<< endl; for (int i = 0; i < Ts.len; i++){ cout << Ts.data[i].i << " " << Ts.data[i].j << " " << Ts.data[i].e << endl; } }
输出稀疏矩阵原形: output_p.cpp
#include <iostream> using namespace std; #include "trituple.h" void Trituple::output_p(TriSeqMatrix Ts){ int k_temp = 0; //用来遍历K的值 int j = 0; for (int i = 0;i < Ts.m; i++){ //扫描行 for (j = 0; j < Ts.n; j++){ //扫描子列 if (Ts.data[k_temp].i == i && Ts.data[k_temp].j == j){ cout << Ts.data[k_temp].e << " "; if (j == Ts.n - 1 ){ cout << endl; } k_temp++; } else{ cout << "0 "; if (j == Ts.n - 1 ){ cout << endl; } } } } return; }
转置算法: transposition.cpp
#include <iostream> using namespace std; #include "trituple.h" void Trituple::transposition(TriSeqMatrix Ts){ output_p(Ts); cout << "转置 ======>>>" << endl; int temp = 0; TriSeqMatrix temp_ts; temp = Ts.m; Ts.m = Ts.n; Ts.n = temp; int i = 0; for (i = 0; i < Ts.len; i++){ temp = Ts.data[i].i; Ts.data[i].i = Ts.data[i].j; Ts.data[i].j = temp; } int j = 0; for (i = 0; i < Ts.len; i++){ for (j = i + 1; j < Ts.len; j++){ if (Ts.data[i].i > Ts.data[j].i){ temp_ts.data[1] = Ts.data[i]; Ts.data[i] = Ts.data[j]; Ts.data[j] = temp_ts.data[1]; } else{ if (Ts.data[i].i == Ts.data[j].i){ if (Ts.data[i].j > Ts.data[j].j){ temp_ts.data[1] = Ts.data[i]; Ts.data[i] = Ts.data[j]; Ts.data[j] = temp_ts.data[1]; } } } } } output_p(Ts); }
相加算法: add.cpp
#include <iostream> using namespace std; #include "trituple.h" void Trituple::add(TriSeqMatrix Ts, TriSeqMatrix Ts2){ TriSeqMatrix addTs; if (Ts.m != Ts2.m || Ts.n != Ts.n){ cout << "两个稀疏矩阵大小不相等, 无法进行相加 " << endl; } else{ addTs.n = Ts.n; //给出列 addTs.m = Ts.m; //给出行 int small = 0; //小的在前面 int big = 0; if (Ts.len < Ts2.len){ small = Ts.len; big = Ts2.len; } else{ small = Ts2.len; big = Ts.len; } int temp = 0; int j = 0; for (int i = 0; i < big; i++){ for (; j < small; ){ if (Ts.data[i].i < Ts2.data[j].i){ addTs.data[temp] = Ts.data[i]; temp++; break; } else{ if (Ts.data[i].i > Ts2.data[j].i){ addTs.data[temp] = Ts2.data[j]; temp++; j++; break; } else{ if (Ts.data[i].j > Ts2.data[j].j){ addTs.data[temp] = Ts2.data[j]; temp++; j++; break; } else{ if (Ts.data[i].j < Ts2.data[j].j){ addTs.data[temp] = Ts.data[i]; temp++; break; } else{ addTs.data[temp].i = Ts.data[i].i; addTs.data[temp].j = Ts.data[i].j; addTs.data[temp].e = Ts.data[i].e + Ts2.data[j].e; temp++; j++; break; } } } } } if (j == small){ addTs.data[temp] = Ts.data[i]; temp++; } } addTs.len = temp - 1; //显示 output_p(Ts); cout << " 相加 + " << endl; output_p(Ts2); cout << "-----------------结果" << endl; output_p(addTs); } }
相乘算法: multiply.cpp
#include <iostream> using namespace std; #include "trituple.h" void Trituple::multiply(TriSeqMatrix Ts, TriSeqMatrix Ts2){ output_p(Ts); cout << " 相乘 + " << endl; output_p(Ts2); cout << "-----------------结果" << endl; TriSeqMatrix Mu; Mu.m = Ts.m; Mu.n = Ts2.n; if (Ts.n != Ts2.m){ cout << "两个矩阵不符合相乘的条件, 无法进行乘法运算" << endl; return; } //预处理Ts2,得出列的种类 //int temp = Ts2.data[0].j; //第一个值得列 int *Ts2Hang = new int(Ts2.n); //动态内存分配,志华提供 //int Ts2Hang[Ts2.len]; int k = 0; for (k = 0; k < Ts2.n; k++){ int t = 0; for (t = 0; t < Ts2.len; t++){ if (Ts2.data[t].j == k){ Ts2Hang[k] = Ts2.data[t].j; break; } } } k = 0; int sum = 0; int temp = 0; int power2 = 0; //尾 int power = 0; //头 for (int i = 0; i < Ts.len; i++){ for (int j = 0; j < Ts2.len; j++){ if (Ts2.data[j].j == Ts2Hang[k]){ if (Ts2.data[j].i == Ts.data[i].j){ sum += Ts.data[i].e * Ts2.data[j].e; break; } } } if (Ts.data[i].i != Ts.data[i+1].i){ Mu.data[temp].i = Ts.data[i].i; Mu.data[temp].j = Ts2Hang[k]; Mu.data[temp].e = sum; temp++; sum = 0; power = power2; power2 = i; if (k == Ts2.n - 1){ i = power2; k = 0; } else{ k++; i = power; } } } output_p(Mu); }
提供数据测试:
6 7 9 0 3 9 1 1 3 2 2 7 2 3 2 3 0 7 3 4 -2 4 2 4 4 3 7 5 4 5 6 7 9 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 7 6 9 0 3 7 1 1 3 2 2 7 2 4 4 3 0 9 3 2 2 3 4 7 4 3 -2 4 5 5 7 6 9 0 0 0 7 0 0 0 3 0 0 0 0 0 0 7 0 4 0 9 0 2 0 7 0 0 0 0 -2 0 5 0 0 0 0 0 0 0 0 0 0 0 0 7 6 9 3 0 9 1 1 3 2 2 7 3 2 2 0 3 7 4 3 -2 2 4 4 3 4 7 4 5 5 7 6 6 0 3 1 0 5 2 2 0 4 3 4 7 6 2 8 6 5 9 6 2 5 0 3 0 0 0 0 5 0 1 2 0 4 3 4 4 0 0 2 0 3 9 1 1 -1 2 3 5 4 2 3 2 0 0 -1 3 0 0 0 5 4 8 0 1 1 0 3 1 1 0 1 2 0 2 2 3 1 3 0 3 3 1 1 4 3 1 4 3 12 2 3 1 3 4 1 4 1 1 1 1 1 2 4 6 0 0 1 0 2 3 0 3 -1 1 0 2 1 1 1 1 3 2 4 3 10 4 1 0 -1 1 3 2 0 1 1 3 4
测试结果 1:
功能演示========================================== 功能1:输入已压缩的稀疏矩阵,转换成稀疏矩阵原形===== 请输入稀疏矩阵的行数, 列数, 非零元素个数: 6 7 9 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 0 3 9 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 1 1 3 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 2 2 7 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 2 3 2 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 3 0 7 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 3 4 -2 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 4 2 4 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 4 3 7 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 5 4 5 稀疏矩阵原形: 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 ================================================== 功能2:输入稀疏矩阵原形,转换成压缩稀疏矩阵========= 请输入稀疏矩阵的行数, 列数, 非零元素个数: 6 7 9 请规范输入稀疏矩阵: 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 稀疏矩阵原形压缩后为(行,列,值): 0 3 9 1 1 3 2 2 7 2 3 2 3 0 7 3 4 -2 4 2 4 4 3 7 5 4 5 ================================================== 功能3:将稀疏矩阵转置============================== 转置功能1的稀疏矩阵=============================== 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 转置 ======>>> 0 0 0 7 0 0 0 3 0 0 0 0 0 0 7 0 4 0 9 0 2 0 7 0 0 0 0 -2 0 5 0 0 0 0 0 0 0 0 0 0 0 0 转置功能2的稀疏矩阵=============================== 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 转置 ======>>> 0 0 0 7 0 0 0 3 0 0 0 0 0 0 7 0 4 0 9 0 2 0 7 0 0 0 0 -2 0 5 0 0 0 0 0 0 0 0 0 0 0 0 ================================================== 功能4:将稀疏矩阵1 和 2相加======================== 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 相加 + 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 -----------------结果 0 0 0 18 0 0 0 0 6 0 0 0 0 0 0 0 14 4 0 0 0 14 0 0 0 -4 0 0 0 0 8 14 0 0 0 0 0 0 0 10 0 0 ================================================== 功能5:将稀疏矩阵1 和 2相乘======================== 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 相乘 + 0 0 0 9 0 0 0 0 3 0 0 0 0 0 0 0 7 2 0 0 0 7 0 0 0 -2 0 0 0 0 4 7 0 0 0 0 0 0 0 5 0 0 -----------------结果 两个矩阵不符合相乘的条件, 无法进行乘法运算 请按任意键继续. . .
测试结果 2:
功能演示========================================== 功能1:输入已压缩的稀疏矩阵,转换成稀疏矩阵原形===== 请输入稀疏矩阵的行数, 列数, 非零元素个数: 2 4 6 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 0 0 1 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 0 2 3 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 0 3 -1 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 1 0 2 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 1 1 1 请输入稀疏矩阵的非零元素,分别输入行,列, 和值: 1 3 2 稀疏矩阵原形: 1 0 3 -1 2 1 0 2 ================================================== 功能2:输入稀疏矩阵原形,转换成压缩稀疏矩阵========= 请输入稀疏矩阵的行数, 列数, 非零元素个数: 4 3 10 请规范输入稀疏矩阵: 4 1 0 -1 1 3 2 0 1 1 3 4 稀疏矩阵原形压缩后为(行,列,值): 0 0 4 0 1 1 1 0 -1 1 1 1 1 2 3 2 0 2 2 2 1 3 0 1 3 1 3 3 2 4 ================================================== 功能3:将稀疏矩阵转置============================== 转置功能1的稀疏矩阵=============================== 1 0 3 -1 2 1 0 2 转置 ======>>> 1 2 0 1 3 0 -1 2 转置功能2的稀疏矩阵=============================== 4 1 0 -1 1 3 2 0 1 1 3 4 转置 ======>>> 4 -1 2 1 1 1 0 3 0 3 1 4 ================================================== 功能4:将稀疏矩阵1 和 2相加======================== 两个稀疏矩阵大小不相等, 无法进行相加 ================================================== 功能5:将稀疏矩阵1 和 2相乘======================== 1 0 3 -1 2 1 0 2 相乘 + 4 1 0 -1 1 3 2 0 1 1 3 4 -----------------结果 9 -3 0 0 0 11 请按任意键继续. . .