稀疏矩阵存储 (1)三元组(2)十字链表

三对角矩阵

![在这里插入图片描述](https://img-blog.csdnimg.cn/20190621112929982.png?x-oss-

1 三元组(triple)

0 参考博客链接, 请点击

1 图解

Code

三元组的加法

核心思想

int cmp(Triple m1, Triple m2)
{
    if(m1.i == m2.i)
    {
        if(m1.j == m2.j)
            return 0;
        else if(m1.j < m2.j)
            return -1;
        else
            return 1;
    }
    else if(m1.i < m2.i)
        return -1;
    else
        return 1;
}

1.1 三元组应用例题

code

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>

using namespace std;

#define OK true
#define ERROR false

#define MaxSize 100

//typedef long long ll;

//定义三元组线性表中的数据元素存储结构
typedef struct
{
    int row;        //行号
    int col;        //列号
    int d;    //元素值，ElemType为数据元素类型

} TupNode; //三元组定义

//定义三元组线性表存储结构
typedef struct
{
    int rows;                   //三元组的总行数值,是TupNode一层一层推起来的
    int cols;                   //列数值
    int nums;                   //非零元素个数
    TupNode data[MaxSize];      //data数据域

} TSMatrix; //三元组顺序表定义

void swap_(int& a, int& b)
{
    int temp;
    temp=a;
    a=b;
    b=temp;
}

//以行序方式扫描二维矩阵A，将其非零的元素加入到三元组t
//以3行4列的稀疏矩阵为例
// No error
void CreatMat(TSMatrix *t, int arr[3][4])
{
    int i;
    int j;
    t->rows = 3;
    t->cols = 4;
    t->nums = 0;

    //扫描矩阵中的非零元素
    for(i = 0; i < 3; i++)
    {
        for(j = 0; j < 4; j++)
        {
            //只存非零值，以三元组方式
            if(arr[i][j] != 0)
            {
                t->data[t->nums].row = i;
                t->data[t->nums].col = j;
                t->data[t->nums].d = arr[i][j];
                t->nums++;
            }
        }
    }
}

/* 将三元组线性表中指定位置的元素值赋值给e
* nums同时也是data[]的元素个数, data[]元素索引: 0-->(nums-1)
* No error
*/
void arr_Assign(TSMatrix t, int *e, int i, int j)
{
    int k = 0;
    //i和j是否合法, 程序的Robustness
    if(i >= t.rows || j >= t.cols)
    {
        return;
    }

    //找到指定元素的行下标
    while(k < t.nums && i > t.data[k].row)
    {
        k++;
    }

    //当找到指定元素的行下标后，再找到指定元素的列下标
    // 细节: i == t.data[k].row,
    while (k < t.nums && i == t.data[k].row && j > t.data[k].col)
    {
        k++;
    }
    //如果指定元素的行和列都相等，说明找到了
    if(t.data[k].row == i && t.data[k].col==j)
    {
        *e = t.data[k].d;
    }
    else
    {
        //说明没找到
        *e = 0;
    }
}

/* 矩阵转置
*   No error
*/
void Transpose_Matrix(TSMatrix *t)
{
    int i;
    for(i=0; i<t->nums; i++)
    {
        swap_(t->data[i].col, t->data[i].row);
    }

}

/* 规定的排序
*  No error
*/
int cmp(TupNode m1, TupNode m2)
{
    if(m1.row == m2.row)
    {
        if(m1.col == m2.col)
            return 0;
        else if(m1.col < m2.col)
            return -1;
        else if(m1.col > m2.col)
            return 1;
    }
    else if(m1.row < m2.row)
        return -1;
    else if(m1.row > m2.row)
        return 1;
}

/*
*   三元组m1与三元组m2都是递增存储的, m3存储m1+m2的三元组
*   No error
*/
void Matrix_Add(TSMatrix *m1, TSMatrix *m2, TSMatrix *m3)
{
    int i=0, j=0; /* i是m1的索引, j是m2的索引 */
    int k=0;      /* k是m3的索引 */
    while(i < m1->nums && j< m2->nums)
    {
        /* m1.row < m2.row || (m1.row == m2.row && m1.col < m2.col) */
        if( cmp(m1->data[i], m2->data[j]) ==-1 )
        {
            m3->data[k].row = m1->data[i].row;
            m3->data[k].col = m1->data[i].col;
            m3->data[k].d = m1->data[i].d;
            i++;
            k++;
        }
        /* m2.row < m1.row || (m1.row == m2.row && m2.col < m1.col) */
        else if( cmp(m1->data[i], m2->data[j]) == 1 )
        {
            m3->data[k].row = m2->data[j].row;
            m3->data[k].col = m2->data[j].col;
            m3->data[k].d = m2->data[j].d;
            j++;
            k++;
        }
        /* m2.col == m1.col && m2.row == m1.row */
        else
        {
            if(m2->data[j].d + m1->data[i].d == 0)
            {
                i++;
                j++;
                continue;
            }
            m3->data[k].d = m2->data[j].d + m1->data[i].d;
            m3->data[k].col = m2->data[j].col;
            m3->data[k].row = m2->data[j].row;
            i++, j++;
            k++;
        }
    } /* close outer while */

    /* 三元组m1的元素还没遍历完, m2的已经遍历完了 */
    while(i < m1->nums)
    {
        m3->data[k].row = m1->data[i].row;
        m3->data[k].col = m1->data[i].col;
        m3->data[k].d = m1->data[i].d;
        i++;
        k++;
    }
    while(j < m2->nums)
    {
        m3->data[k].row = m2->data[j].row;
        m3->data[k].col = m2->data[j].col;
        m3->data[k].d = m2->data[j].d;
        j++;
        k++;
    }

    m3->nums = k;
}


/* Error */
void as_sign(TSMatrix *A, int& cnt)
{
    A->nums=0;

    int p,q,e;
    while(cnt--)
    {
        scanf("%d %d %d", &p,&q,&e);
        A->data[A->nums].row = p;
        A->data[A->nums].col = q;
        A->data[A->nums].d = e;
        A->nums++;
    }
}

void print_matrix(TSMatrix *A)
{
    for(int i=0; i<A->nums; i++)
    {
        printf("%d %d %d\n",A->data[i].row,A->data[i].col,A->data[i].d);
    }
}

void bubble_sort(TSMatrix *m1)
{
    int i;
    int j;
    for(i=0; i<(m1->nums)-1; i++)
    {
        for(j=0; j<(m1->nums-1)-i; j++)
        {
            if( cmp(m1->data[j], m1->data[j+1]) == 1 )
            {
                TupNode tmp = m1->data[j];
                m1->data[j] = m1->data[j+1];
                m1->data[j+1] = tmp;
            }
        }
    }
}

int main()
{
    //freopen("1.txt","r",stdin);

    int m,n,cnt;

    TSMatrix A,B,C;

    scanf("%d%d%d",&m,&n,&cnt);
    as_sign(&A, cnt);
    //print_matrix(&A);

    scanf("%d%d%d",&m,&n,&cnt);
    as_sign(&B, cnt);
    //print_matrix(&B);

    Matrix_Add(&A, &B, &C);

    Transpose_Matrix(&A);
    bubble_sort(&A);
    printf("%s\n","The transformed matrix  is:");
    print_matrix(&A);

    printf("%s\n","The added matrix is:");
    print_matrix(&C);

    return 0;
}