山东大学数据结构实验报告四.docx
《山东大学数据结构实验报告四.docx》由会员分享，可在线阅读，更多相关《山东大学数据结构实验报告四.docx（41页珍藏版）》请在冰豆网上搜索。
山东大学数据结构实验报告四
山东大学软件工程学院
数据结构课程实验报告
学号：
姓名：
班级：
软件工程2014级2班
实验题目：
矩阵和散列表
实验学时：
实验日期：
2015.11.11
实验目的：
掌握特殊矩阵和稀疏矩阵。
掌握散列表及其应用。
硬件环境：
实验室
软件环境：
VistualStudio2013
实验步骤与内容：
实验内容：
1、创建三对角矩阵类，采用按列映射方式，提供
store和
retrieve
方法。
2、创建下三角矩阵类，采用按列映射方式，提供
store和
retrieve
方法。
3、创建稀疏矩阵类，采用行主顺序把稀疏矩阵映射到一维数组中，实现稀疏矩阵的转
置和两个稀疏矩阵的加法操作。
4、使用散列表设计实现一个字典，假设关键字为整数且D为961，在字典中插入随机产
生的500个不同的整数，实现字典的建立和搜索操作。
分别使用线性开型寻址和链表散
列解决溢出。
代码体：
ChainHashTableNode.h
#pragmaonce
#include"ChainHashTableNode.h"
usingnamespacestd;
classChainHashTable
{
public:
ChainHashTable（intdivisor）;
~ChainHashTable（）;
boolInsert（intk）;
boolSearch（intk）;
voidprint（）;
private:
intd;
ChainHashTableNode*ht;
};
ChainHashTableNode.cpp
#include"ChainHashTable.h"
#include
usingnamespacestd;
ChainHashTable:
:
ChainHashTable（intdivisor）
{
d=divisor;
ht=newChainHashTableNode[d];
}
boolChainHashTable:
:
Insert（intk）
{
int
if
j=k%d;（ht[j].Insert（
k））
{
return
true;
}
else{
returnfalse;
}
}
voidChainHashTable:
:
print（）
{
for（inti=0;i{
ht[i].print（）;
}
}
ChainHashTableNode.h
#pragmaonce
#include"Node.h"
classChainHashTableNode
{
public:
ChainHashTableNode（）;
boolInsert（intk）;
boolSearch（intk）;
voidprint（）;
private:
Node*first;
};
ChainHashTableNode.cpp
#include"ChainHashTableNode.h"
#include
usingnamespacestd;
ChainHashTableNode:
:
ChainHashTableNode（）
{
first=0;
}
boolChainHashTableNode:
:
Search（intk）
{
if（first==0）returnNode*current=first;while（current）{
false;
if（current->value==
{
k）
return
true;
}
current=current->link;
if（current）
{
if（current->value==
{
k）
return
true;
}
}
}
return
false;
}
boolChainHashTableNode:
:
Insert（
int
k）
{
if（Search（k））
{
cout<<"已经存在此元素"<
returnfalse;
}
else{
Node*p=
p->value=
newNode（）;
k;
if（first==0）
{
first=p;
returntrue;
}
else
{
p->link=first;
first=p;
returntrue;
}
}
}
voidChainHashTableNode:
:
print（）
{
Node*current=first;
if（first）
{
while（first）
{
cout<value<<
first=first->link;
"";
}
cout<first=current;
}
else{
cout<<-1<}
}
HashTable.h
#pragmaonce
classHashTable
{
public:
HashTable（intdivisor）;
~HashTable（）;
intSearch（intk）;//搜索算法
boolInsert（inte）;
voidprint（）;
private:
inthSearch（intk）;
intd;//除数
int*ht;//桶，大小取决于d就是除数是多少
bool*empty;//一维数组，用来存储第I个桶是否存入了元素
};
HashTable.cpp
#include"HashTable.h"
#include
usingnamespacestd;
HashTable:
:
HashTable（
int
divisor）
{
d=divisor;
ht=newint[d];
empty=newbool[d];
for（inti=0;i{
empty[i]=
ht[i]=0;
true;
}
}
HashTable:
:
~HashTable（）
{
delete[]ht;
delete[]empty;
}
int
HashTable:
:
hSearch（
int
k）//
搜索值为
K的元素
{
int
int
i=
j=i;
k%d;
do{
if（ht[j]==
j=（j+1）%d;
k||empty[j]）
returnj;
}while（j!
=i）;returnj;
}
int
HashTable:
:
Search（
int
k）//
搜索值为
K的元素
{
intb=hSearch（
if（ht[b]==k）
k）;
return
b;
return-1;
}
boolHashTable:
:
Insert（inte）
{
int
if
b=hSearch（（empty[b]）
e）;
{
ht[b]=e;
empty[b]=
returntrue
false;
;
}
elseif（ht[b]==e）
{
cout<<"已经存在此元素"<returnfalse;
}
else
{
cout<<"表已经满了"<returnfalse;
}
}
voidHashTable:
:
print（）
{
for（inti=0;i<961;i++）{
cout<}
cout<return;
}
LowerTriangularMatrix.h
#pragmaonce
classLowerTriangularMatrix
{
public:
LowerTriangularMatrix（
voidStore（intx,int
intRetrieve（inti,
voidprint（）;
private:
intsize）;
i,intj）;//向矩阵里存储一个元素
intj）;//返回矩阵中的一个元素
intn;//矩阵维数
intsum;//矩阵非零元素个数
int*t;//用数组来存储矩阵
};
LowerTriangularMatrix.cpp
#include"LowerTriangularMatrix.h"
#include
usingnamespacestd;
LowerTriangularMatrix
:
:
LowerTriangularMatrix（
int
size）
{
n=size;
sum=n*（n+1）/2;
t=newint[sum];
}
void
LowerTriangularMatrix
:
:
Store（
int
x,
int
i,
int
j）
{
if
（i<0||
j<0||
i>=n||
j>=n）
{
cout<<
"下三角矩阵行列输入错误
"<<
i<<
""
<return;
}
else
if
（x==0）
{
cout<<
"下三角所添加的元素必须非零
"<return;
}
else
if
（i{
cout<<
"下三角添加元素位置错误
"<return;
}
t[sum-（（n-
j）*（n-
j+1）/2）+（
i-
j）]=
x;
return;
}
int
LowerTriangularMatrix
:
:
Retrieve（
int
i,
int
j）
{
if
（i<0||
j<0||
i>=（n-1）||
j>=（n-1））
{
cout<<"三对角矩阵行列输入错误"<return-1;
}
elseif（i>=j）
{
returnt[sum-（（n-j）*（n-j+1）/2）+（i-j）];
}
else{
return0;
}
}
voidLowerTriangularMatrix:
:
print（）
{
for（inti=0;icout<}
cout<return;
}
Node.h
#pragmaonce
classNode
{
friendclassChainHashTableNode;
private:
intvalue;
Node*link;
};
Node.cpp
#include
"Node.h"
using
namespacestd;
SparseMatrix.h
#pragmaonce
#include
"Term.h"
class
SparseMatrix
{
public
:
SparseMatrix（
int
row,
int
col）;
void
transpose（）;
void
Store（int
x,
int
i,
int
j）;//向矩阵里存储一个元素
void
Add（SparseMatrix
&b）;//
两个稀疏矩阵相加
void
print（）;
private
:
int
row,col;
//数组维数
int
sum;//元素个数
int
maxsum;//最多的元素个数
Term*t;//存储的数组
};
SparseMatrix.cpp
#include
"SparseMatrix.h"
#include
using
namespacestd;
SparseMatrix
:
:
SparseMatrix（
intr,intc）
{
row=
r;
col=
c;
sum=0;
maxsum=r*c;
t=
newTerm[maxsum];
}
void
SparseMatrix
:
:
transpose（）
{
Term*cur=
newTerm[maxsum];
int
*ColSize=
newint
[col];
int
*RowNext=newint
[row];
for
（
int
i=0;ifor
（
int
i=0;ifor
（
int
i=0;i//表示每一列的非零元素个数
RowNext[0]=0;
for
（
int
i=1;i//表示新矩阵中每一行
的矩阵的前面的矩阵的个数
//进入转置操作
for（inti=0;i{
intj=RowNext[t[i].col]++;
cur[j].value=t[i].value;
cur[j].col=t[i].row;
cur[j].row=t[i].col;
}
deletet;
t=cur;
}
voidSparseMatrix:
:
Store（intx,inti,intj）
{
t[sum].value=x;
t[sum].row=i;
t[sum].col=j;
sum++;
return;
}
voidSparseMatrix:
:
print（）
{
for（inti=0;i
"";
}
cout<return;
}
voidSparseMatrix:
:
Add（SparseMatrix&b）//两个稀疏矩阵相加
{
if（col!
=
cout<<
b.col||row!
=b.row）{
"两个矩阵行列不同无法相加
"<return;
}
intsa=0;
intsb=0;
Term*cur=newTerm[maxsum];
intk=0;
while（sa{
if（t[sa].col==
b.t[sb].col&&t[sa].row==
b.t[sb].row）
{
cur[k].col=t[sa].col;
cur[k].row=t[sa].row;
cur[k].value=t[sa].value+b.t[sb].value;
k++;
sa++;
sb++;
}
elseif（t[sa].row{
cur[k].value=t[sa].value;
cur[k].row=t[sa].row;
cur[k].col=t[sa].col;
k++;
sa++;
}
elseif（t[sa].row>b.t[sb].row）
{
cur[k].value=
cur[k].row=
cur[k].col=
k++;
b.t[sb].value;
b.t[sb].row;
b.t[sb].col;
sb++;
}
elseif（t[sa].col{
cur[k].col=t[sa].col;
cur[k].row=t[sa].row;
cur[k].value=t[sa].value;
k++;
sa++;
}
else
{
cur[k].value=
cur[k].row=
cur[k].col=
k++;
sb++;
b.t[sb].value;
b.t[sb].row;
b.t[sb].col;
}
}
sum=k;
deletet;
t=cur;
return;
}
Term.h
#pragmaonce
classTerm
{
friendclassSparseMatrix;
private:
intcol,row;
intvalue;
};
Term.cpp
#include"Term.h"
TridiagonalMatrix.h
#pragmaonce
classTridiagonalMatrix
{
public:
TridiagonalMatrix（
voidStore（intx,
intRetrieve（inti,
voidprint（）;
intsize）;
inti,intj）;//向矩阵里存储一个元素
intj）;//返回矩阵中的一个元素
private:
intn;//矩阵非0元素个数
int*t;//用数组来存储矩阵
};
TridiagonalMatrix.cpp
#include"TridiagonalMatrix.h"
#include
usingnamespacestd;
TridiagonalMatrix
:
:
TridiagonalMatrix（
int
size）
{
n=size;
t=newint[3*n-2];
}
voidTridiagonalMatrix
:
:
Store（
int
x,
int
i,
int
j）
{
if（i<0||
j<0||
i>=n||
j>=n）
{
cout<<"三对角矩阵行列输入错误"<
}
elseif（x==0）
{
cout<<"三对角矩阵所添加的元素必须非零"<return;
}
elseif（abs（i-j）>1）
{
cout<<"三对角矩阵添加元素位置错误"<return;
}
switch（i-
j）
{
case-1:
t[3*
j-1]=
x;
break;
case0:
t[3*
j]=x;
break;
case1:
t[3*
j+1]=
x;
break;
}
return;
}
int
TridiagonalMatrix
:
:
Retrieve（
int
i,int
j）
{
if
（i<0||
j<0||
i>=（n-1）||
j>=（n-1））
{
cout<<"三对角矩阵行列输入错误"<return-1;
}
else
if
（abs（
i-
j）<=1）
{
return
t[3*
j+（
i-
j）];
}
else{
return
0;
}
}
voi
升级会员 