稀疏矩阵操作算法

测试: demo.cpp

#include "trituple.h"
#include <iostream>
using namespace std;

int main(){
    Trituple data1;
    Trituple data2;
    cout << "功能演示==========================================" << endl;
    cout << "功能1:输入已压缩的稀疏矩阵,转换成稀疏矩阵原形=====\n" << endl;
    TriSeqMatrix Ts = data1.input(); //输入已压缩
    cout << "稀疏矩阵原形: " << endl;
    data1.output_p(Ts); //输出原形
    cout << "\n==================================================" << endl;
    cout << "功能2:输入稀疏矩阵原形,转换成压缩稀疏矩阵=========\n" << endl;
    TriSeqMatrix Ts2 = data2.input_p();
    data2.output(Ts2);
    cout << "\n==================================================" << endl;
    cout << "功能3:将稀疏矩阵转置==============================" << endl;
    cout << "转置功能1的稀疏矩阵===============================\n" << endl;
    data1.transposition(Ts);
    cout << "\n转置功能2的稀疏矩阵===============================\n" << endl;
    data2.transposition(Ts2);
    cout << "\n==================================================" << endl;
    cout << "功能4:将稀疏矩阵1 和 2相加========================\n" << endl;
    data1.add(Ts, Ts2);
    cout << "\n==================================================" << endl;
    cout << "功能5:将稀疏矩阵1 和 2相乘========================\n" << 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 << "两个稀疏矩阵大小不相等, 无法进行相加\n" << 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 << "\t\t相加 + " << 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 << "\t\t相乘 + " << 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
请按任意键继续. . .

时间： 2024-10-13 19:07:56

稀疏矩阵操作算法的相关文章

STL之heap相关操作算法

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 堆(heap)是一种非常重要的数据结构(这里我们讨论的是二叉堆),它是一棵满足特定条件的完全二叉树,堆的定义如下: 堆是一棵树完全二叉树,对于该完全二叉树中的每一个结点x,其关键字大于等于(或小于等于)其左右孩子结点,而其左右子树均为一个二叉堆. 在上述的定义中,若堆中父亲结点关键字的值大于等于孩子结点,则称该堆为大顶堆:若堆中父亲结点关键子的值小于等于孩子结点,则称该堆为小顶堆. 由于堆是一棵完全二叉树,所以我们可以很轻易地用一个数组存储堆中

数据结构（C语言版）链表相关操作算法的代码实现

这次实现的是带头结点的单链表的初始化.遍历.创建.插入.删除.判断链表是否为空.求链表长度函数,编译环境是vs2013. 其中插入和删除函数中循环的条件目前还不太明白. #include<iostream> using namespace std; typedef int Status; typedef char Elemtype; //定义链表的存储结构,注意这里与算法的定义有一处不同,是定义结构体时就命名Lnode,说明*next的类型只要说是Lnode类型就可以 typedef stru

稀疏矩阵操作（三元组表示法）

#include <cstdio> #include <cstdlib> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 100 typedef int Status; typedef float ElemType; typedef struct{//三元组结构 int i, j;//非零元素行下标和列下标 ElemType e;//非零元素值 }Triple; typedef

串操作算法虚拟实现

//串:它是有限字符集中的零个或多个字符组成的有限序列 //一种特殊的线性表 int indexz(String S,String T,int pos) { //T为非空串,若主串S中第pos个字符之后存在与T相等 //的子串,则返回第一个这样的子串在S中的位置 if(pos>0) { n=StrLength(S);//求出主字符串的长度 m=StrLength(T);//求出非空串的长度 i=pos; while(i<=n-m+1) { SubString(sub,S,i,m); if(St

数据结构-单链队列相关操作算法

#include <stdio.h>#include <stdlib.h> #define OVERFLOW -2#define OK 1#define ERROR 0 typedef int QElemType; //单链队列结构体定义typedef struct QNode {    QElemType data;    struct QNode *next;}QNode,*QueuePtr;typedef struct {    QueuePtr front;    Queu

数据结构-栈有关操作算法

#include <stdio.h>#include <stdlib.h> #define STACK_INIT_SIZE 100#define STACKINCREMENT 10#define OVERFLOW -2#define OK 1#define ERROR 0 typedef int SElemType; //栈结构体typedef struct {    SElemType *base;    SElemType *top;    int stacksize;}SqS

STL C++ std::bind操作例子，仿函数操作配合算法库操作

1.stl::bind 和std::mem_fun_ref系列的配合使用出现了问题,多参形式不知道如何组织.适配器的操作真心难受!!!只能迷迷糊糊地用着.要使用非质变算法时需要作用于容器时只能考虑lambda或者transfer操作.待续 // functor-adapter_p431.cpp : 定义控制台应用程序的入口点. // #include "stdafx.h" #include <algorithm>//元素操作算法 #include <functiona

MATLAB命令大全和矩阵操作大全

转载自: http://blog.csdn.net/dengjianqiang2011/article/details/8753807 MATLAB矩阵操作大全 一.矩阵的表示在MATLAB中创建矩阵有以下规则: a.矩阵元素必须在"[ ]"内: b.矩阵的同行元素之间用空格(或",")隔开: c.矩阵的行与行之间用";"(或回车符)隔开: d.矩阵的元素可以是数值.变量.表达式或函数: e.矩阵的尺寸不必预先定义. 二,矩阵的创建: 1.直接输

数据结构及算法答案

1.1 简述下列术语:数据,数据元素.数据对象.数据结构.存储结构.数据类型和抽象数据类型. 解:数据是对客观事物的符号表示.在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称.     数据元素是数据的基本单位,在计算机程序中通常作为一个整体进行考虑和处理.     数据对象是性质相同的数据元素的集合,是数据的一个子集.     数据结构是相互之间存在一种或多种特定关系的数据元素的集合.     存储结构是数据结构在计算机中的表示.     数据类型是一个值的集合和定义在这个