实验内容
- 实现顺序串(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);
顺序串实现效果图如下:
- 稀疏矩阵的存储及基本运算。
(1)针对给出的两个稀疏矩阵a和b,分别输出各自的三元组表示形式。
其中,a,b矩阵表示如下:
(2)实现a,b稀疏矩阵的求和运算,并以三元组的形式表示,预期结果如下图所示:
设计思路
- 实现顺序串(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)来进行串的连接 - 稀疏矩阵的存储及基本运算。
首先定义两个二个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;
}