【数据结构】串和稀疏矩阵的基本运算

---

实验内容

1. 实现顺序串(SqString.cpp)中各种基本运算的算法，具体操作要求如下：
   （1）初始化串并赋值
   例如：StrAssign(s,“abcdefghijklmn”); StrAssign(s1,“123”);
   即：主串S为：”abcdefghijklmn” 子串S1为：”123”
   （2）串的输出 例如：DispStr(s)
   （3）串的长度 例如：StrLength(s)
   （4）串的插入，串的删除，串的替换
   例如：InsStr(s,9,s1); DelStr(s,2,3); RepStr(s,2,5,s1);
   （5）求子串，串的连接
   例如：SubStr(s,2,10); Concat(s1,s2);
   顺序串实现效果图如下：
   

2. 稀疏矩阵的存储及基本运算。
   （1）针对给出的两个稀疏矩阵a和b，分别输出各自的三元组表示形式。
   其中，a，b矩阵表示如下：

（2）实现a，b稀疏矩阵的求和运算，并以三元组的形式表示，预期结果如下图所示：

---

设计思路

1. 实现顺序串(SqString.cpp)中各种基本运算的算法，具体操作要求如下：
   （1）初始化串并赋值
   调用StrAssign(SqString &s,char cstr[])函数来初始化顺序串s和s1
   （2）串的输出
   调用DispStr(SqString s)函数来输出串（在字符不等于\0的条件下按顺序输出串中的值）
   （3）串的长度
   调用StrLength(SqString s)函数来输出串的长度（返回s.length）
   （4）串的插入，串的删除，串的替换
   调用InsStr(SqString s1,int i,SqString s2)来进行串的插入
   调用DelStr(SqString s,int i,int j)来进行串的删除
   调用RepStr(SqString s,int i,int j,SqString t)来进行串的替换
   （5）求子串，串的连接
   调用SubStr(SqString s,int i,int j)来提取子串
   调用Concat(SqString s,SqString t)来进行串的连接
2. 稀疏矩阵的存储及基本运算。
   首先定义两个二个4*4数组并对其初始化
   ElemType A[N][N] = {
   {1, 0, 3, 0},
   {0, 1, 0, 0},
   {0, 0, 1, 0},
   {0, 0, 1, 1}
   };
   ElemType B[N][N] = {
   {3, 0, 0, 0},
   {0, 4, 0, 0},
   {0, 0, 1, 2},
   {0, 0, 0, 2}
   };
   （1）针对给出的两个稀疏矩阵a和b，分别输出各自的三元组表示形式。
   调用CreatMat(TSMatrix &t,ElemType A[M][N]) 从一个二维稀疏矩阵创建其三元组表示
   （2）实现a，b稀疏矩阵的求和运算，并以三元组的形式表示，预期结果如下图所示：
   调用Matrix_Add(TSMatrix a, TSMatrix b, TSMatrix &c)来对A+B进行运算
   调用DispMat(TSMatrix t)来输出三元组

---

实验代码

#include <iostream>
#include<bits/stdc++.h>
#define MaxSize 100
#include"hearder.h"
using namespace std;

int main()
{
    SqString s,s1,s2,s3,s4;
    printf("顺序串的基本运算如下\n");
    printf("(1)建立串s和串s1\n");
    StrAssign(s,"abcdefghijklmn");
    StrAssign(s1,"123");
    printf("(2)输出串s：");
    DispStr(s);
    printf("(3)串s的长度：");
    printf("%d\n",StrLength(s));
    printf("(4)在串s的第9个字符位置插入串s1而产生串s2\n");
    s2=InsStr(s,9,s1);
    printf("(5)输出串s2：");
    DispStr(s2);
    printf("(6)删除串s第2个字符开始的5个字符替换成串s1而产生串s2\n");
    s2=DelStr(s,2,3);
    printf("(7)输出串s2：");
    DispStr(s2);
    printf("(8)将串s的第2个字符开始的第5个字符替换成串s1而产生串s2\n");
    s2=RepStr(s,2,5,s1);
    printf("(9)输出串s2：");
    DispStr(s2);
    printf("(10)提取串s的第2个字符开始的10个字符而产生串s3\n");
    s3=SubStr(s,2,10);
    printf("(11)输出串s3：");
    DispStr(s3);
    printf("(12)将串s1和串s2连接起来而产生串s4\n");
    s4=Concat(s1,s2);
    printf("(13)输出串s4：");
    DispStr(s4);
    return 0;

#include <stdio.h>
#define MaxSize 100    			//最多的字符个数
typedef struct
{
    char data[MaxSize];			//定义可容纳MaxSize个字符的空间
    int length;             	//标记当前实际串长
} SqString;
void StrAssign(SqString &s,char cstr[])	//s为引用型参数
{
    int i;
    for (i=0; cstr[i]!='\0'; i++)
        s.data[i]=cstr[i];
    s.length=i;
}
void StrCopy(SqString &s,SqString t)	//s为引用型参数
{
    int i;
    for (i=0; i<t.length; i++)
        s.data[i]=t.data[i];
    s.length=t.length;
}
bool StrEqual(SqString s,SqString t)
{
    bool same=true;
    int i;
    if (s.length!=t.length)				//长度不相等时返回0
        same=false;
    else
        for (i=0; i<s.length; i++)
            if (s.data[i]!=t.data[i])	//有一个对应字符不相同时返回0
            {
                same=false;
                break;
            }
    return same;
}
int StrLength(SqString s)
{
    return s.length;
}
SqString Concat(SqString s,SqString t)
{
    SqString str;
    int i;
    str.length=s.length+t.length;
    for (i=0; i<s.length; i++)	//将s.data[0..s.length-1]复制到str
        str.data[i]=s.data[i];
    for (i=0; i<t.length; i++)	//将t.data[0..t.length-1]复制到str
        str.data[s.length+i]=t.data[i];
    return str;
}
SqString SubStr(SqString s,int i,int j)
{
    SqString str;
    int k;
    str.length=0;
    if (i<=0 || i>s.length || j<0 || i+j-1>s.length)
        return str;					//参数不正确时返回空串
    for (k=i-1; k<i+j-1; k++)  		//将s.data[i..i+j]复制到str
        str.data[k-i+1]=s.data[k];
    str.length=j;
    return str;
}
SqString InsStr(SqString s1,int i,SqString s2)
{
    int j;
    SqString str;
    str.length=0;
    if (i<=0 || i>s1.length+1)  //参数不正确时返回空串
        return str;
    for (j=0; j<i-1; j++)      		//将s1.data[0..i-2]复制到str
        str.data[j]=s1.data[j];
    for (j=0; j<s2.length; j++)		//将s2.data[0..s2.length-1]复制到str
        str.data[i+j-1]=s2.data[j];
    for (j=i-1; j<s1.length; j++)		//将s1.data[i-1..s1.length-1]复制到str
        str.data[s2.length+j]=s1.data[j];
    str.length=s1.length+s2.length;
    return str;
}
SqString DelStr(SqString s,int i,int j)
{
    int k;
    SqString str;
    str.length=0;
    if (i<=0 || i>s.length || i+j>s.length+1) //参数不正确时返回空串
        return str;
    for (k=0; k<i-1; k++)       		//将s.data[0..i-2]复制到str
        str.data[k]=s.data[k];
    for (k=i+j-1; k<s.length; k++)	//将s.data[i+j-1..s.length-1]复制到str
        str.data[k-j]=s.data[k];
    str.length=s.length-j;
    return str;
}
SqString RepStr(SqString s,int i,int j,SqString t)
{
    int k;
    SqString str;
    str.length=0;
    if (i<=0 || i>s.length || i+j-1>s.length) //参数不正确时返回空串
        return str;
    for (k=0; k<i-1; k++)				//将s.data[0..i-2]复制到str
        str.data[k]=s.data[k];
    for (k=0; k<t.length; k++)   		//将t.data[0..t.length-1]复制到str
        str.data[i+k-1]=t.data[k];
    for (k=i+j-1; k<s.length; k++)	//将s.data[i+j-1..s.length-1]复制到str
        str.data[t.length+k-j]=s.data[k];
    str.length=s.length-j+t.length;
    return str;
}
void DispStr(SqString s)
{
    int i;
    if (s.length>0)
    {
        for (i=0; i<s.length; i++)
            printf("%c",s.data[i]);
        printf("\n");
    }
}

#include <iostream>
using namespace std;
#include"TSMartix.h"
int main()
{
    TSMatrix t1,t2,t3;
    ElemType A[N][N] =
    {
        {1, 0, 3, 0},
        {0, 1, 0, 0},
        {0, 0, 1, 0},
        {0, 0, 1, 1}
    };
    ElemType B[N][N] =
    {
        {3, 0, 0, 0},
        {0, 4, 0, 0},
        {0, 0, 1, 2},
        {0, 0, 0, 2}
    };
    printf("a的三元组：\n");
    CreatMat(t1,A);
    DispMat(t1);
    printf("b的三元组：\n");
    CreatMat(t2,B);
    DispMat(t2);
    printf("a与b相加后的三元组:\n");
    Matrix_Add(t1, t2, t3);
    DispMat(t3);
    return 0;

}

//稀疏矩阵的三元组表示-算法
#include <stdio.h>
#define M 4
#define N 4
#define MaxSize  100         //矩阵中非零元素最多个数
typedef int ElemType;
typedef struct
{
    int r;					//行号
    int c;					//列号
    ElemType d;				//元素值
} TupNode;					//三元组定义
typedef struct
{
    int rows;				//行数
    int cols;				//列数
    int nums;				//非零元素个数
    TupNode data[MaxSize];
} TSMatrix;					//三元组顺序表

void CreatMat(TSMatrix &t,ElemType A[M][N])  //从一个二维稀疏矩阵创建其三元组表示
{
    int i,j;
    t.rows=M;
    t.cols=N;
    t.nums=0;
    for (i=0; i<M; i++)
    {
        for (j=0; j<N; j++)
            if (A[i][j]!=0) 	//只存储非零元素
            {
                t.data[t.nums].r=i;
                t.data[t.nums].c=j;
                t.data[t.nums].d=A[i][j];
                t.nums++;
            }
    }
}
void DispMat(TSMatrix t)		//输出三元组
{
    int i;
    if (t.nums<=0)			//没有非零元素时返回
        return;
    printf("\t%d\t%d\t%d\n",t.rows,t.cols,t.nums);
    printf("\t------------------\n");
    for (i=0; i<t.nums; i++)
        printf("\t%d\t%d\t%d\n",t.data[i].r,t.data[i].c,t.data[i].d);
}

bool Matrix_Add(TSMatrix a, TSMatrix b, TSMatrix &c) // 引用类型形参c
{
    int i = 0; // a中非零元素个数索引
    int j = 0; // b中非零元素个数索引
    int k = 0; // c中非零元素个数
    ElemType v;

    if(a.rows != b.rows || a.cols != b.cols) // 行数或列数不等时不能进行相加运算
        return false;
    // c的行列数与a的相同
    c.rows = a.rows;
    c.cols = a.cols;
    while(i < a.nums && j < b.nums) // 处理a和b中的元素(假设 a.nums = 6, b.nums = 4)
    {
        if(a.data[i].r == b.data[j].r) // a元素的行号等于b元素的行号
        {
            if(a.data[i].c < b.data[j].c) // a元素的列号小于b元素的列号
            {
                // 将a元素添加到c中
                c.data[k].r = a.data[i].r;
                c.data[k].c = a.data[i].c;
                c.data[k].d = a.data[i].d;
                k++;
                i++;
            }
            else if(a.data[i].c > b.data[j].c) // a元素的列号大于b元素的列号
            {
                // 将b元素添加到c中
                c.data[k].r = b.data[j].r;
                c.data[k].c = b.data[j].c;
                c.data[k].d = b.data[j].d;
                k++;
                j++;
            }
            else // a元素的列号等于b元素的列号
            {
                v = a.data[i].d + b.data[j].d;
                if(v != 0) // 只将不为0的结果添加到c中
                {
                    c.data[k].r = a.data[i].r;
                    c.data[k].c = a.data[i].c;
                    c.data[k].d = v;
                    k++;
                }
                i++;
                j++;
            }
        }
        else if(a.data[i].r < b.data[j].r) // a元素的行号小于b元素的行号
        {
            // 将a元素添加到c中
            c.data[k].r = a.data[i].r;
            c.data[k].c = a.data[i].c;
            c.data[k].d = a.data[i].d;
            k++;
            i++;
        }
        else // a元素的行号大于b元素的行号
        {
            // 将b元素添加到c中
            c.data[k].r = b.data[j].r;
            c.data[k].c = b.data[j].c;
            c.data[k].d = b.data[j].d;
            k++;
            j++;
        }
        c.nums = k;
    }
    return true;
}