山东大学数据结构实验报告四

大学软件工程学院

数据结构课程实验报告

using namespace std;

class ChainHashTable

{

public:

ChainHashTable(int divisor);

~ChainHashTable();

bool Insert(int k);

bool Search(int k);

void print();

private:

int d;

ChainHashTableNode *ht;

};

ChainHashTableNode.cpp

#include"ChainHashTable.h"

#include

using namespace std;

ChainHashTable::ChainHashTable(int divisor) {

d = divisor;

ht = new ChainHashTableNode[d];

}

bool ChainHashTable::Insert(int k)

{

int j = k%d;

if (ht[j].Insert(k))

{

return true;

}

else{

return false;

}

}

void ChainHashTable::print()

{

for (int i = 0; i < d; i++)

{

ht[i].print();

}

}

ChainHashTableNode.h

#pragma once

#include"Node.h"

class ChainHashTableNode

{

public:

ChainHashTableNode();

bool Insert(int k);

bool Search(int k);

void print();

private:

Node *first;

};

ChainHashTableNode.cpp

#include"ChainHashTableNode.h"

#include

using namespace std; ChainHashTableNode::ChainHashTableNode() {

first = 0;

}

bool ChainHashTableNode::Search(int k) {

if (first == 0) return false;

Node *current = first;

while (current)

{

if (current->value == k)

{

return true;

}

current = current->link;

if (current)

{

if (current->value == k)

{

return true;

}

}

}

return false;

}

bool ChainHashTableNode::Insert(int k) {

if (Search(k))

{

cout << "已经存在此元素" << endl;

return false;

}

else {

Node *p = new Node();

p->value = k;

if (first == 0)

{

first = p;

return true;

}

else

{

p->link = first;

first = p;

return true;

}

}

}

void ChainHashTableNode::print()

{

Node *current = first;

if (first)

{

while (first)

{

cout << first->value << " ";

first = first->link;

}

cout << endl;

first = current;

}

else {

cout << -1 << endl;

}

}

HashTable.h

#pragma once

class HashTable

{

public:

HashTable(int divisor);

~HashTable();

int Search(int k);//搜索算法

bool Insert(int e);

void print();

private:

int hSearch(int k);

int d;//除数

int *ht;//桶，大小取决于d就是除数是多少

bool *empty;//一维数组，用来存储第I个桶是否存入了元素};

HashTable.cpp

#include"HashTable.h"

#include

using namespace std;

HashTable::HashTable(int divisor)

{

d = divisor;

ht = new int[d];

empty = new bool[d];

for (int i = 0; i < d; i++)

{

empty[i] = true;

ht[i] = 0;

}

}

HashTable::~HashTable()

{

delete[]ht;

delete[]empty;

}

int HashTable::hSearch(int k)//搜索值为K的元素

{

int i = k%d;

int j = i;

do{

if (ht[j] == k || empty[j]) return j;

j = (j + 1) % d;

} while (j != i);

return j;

}

int HashTable::Search(int k)//搜索值为K的元素

{

int b = hSearch(k);

if (ht[b] == k) return b;

return -1;

}

bool HashTable::Insert(int e)

{

int b = hSearch(e);

if (empty[b])

{

ht[b] = e;

empty[b] = false;

return true;

}

else if (ht[b] == e)

{

cout << "已经存在此元素" << endl;

return false;

}

else

{

cout << "表已经满了" << endl;

return false;

}

}

void HashTable::print()

{

for (int i = 0; i < 961; i++){

cout << ht[i] << " ";

}

cout << endl;

return;

}

LowerTriangularMatrix.h

#pragma once

class LowerTriangularMatrix

{

public:

LowerTriangularMatrix(int size);

void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素

void print();

private:

int n;//矩阵维数

int sum;//矩阵非零元素个数

int *t;//用数组来存储矩阵

};

LowerTriangularMatrix.cpp

#include"LowerTriangularMatrix.h"

#include

using namespace std;

LowerTriangularMatrix::LowerTriangularMatrix(int size)

{

n = size;

sum = n*(n + 1) / 2;

t = new int[sum];

}

void LowerTriangularMatrix::Store(int x, int i, int j)

{

if (i<0 || j<0 || i >= n || j >= n)

{

cout << "下三角矩阵行列输入错误" << i << " " << j << endl;

return;

}

else if (x == 0)

{

cout << "下三角所添加的元素必须非零" << endl;

return;

}

else if (i

{

cout << "下三角添加元素位置错误" << endl;

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 << "三对角矩阵行列输入错误" << endl;

return -1;

}

else if (i >= j)

{

return t[sum - ((n - j)*(n - j + 1) / 2) + (i - j)];

}

else{

return 0;

}

}

void LowerTriangularMatrix::print()

{

for (int i = 0; i < sum; i++){

cout << t[i] << " ";

}

cout << endl;

return;

}

Node.h

#pragma once

class Node

{

friend class ChainHashTableNode;

private:

int value;

Node *link;

};

Node.cpp

#include"Node.h"

using namespace std;

SparseMatrix.h

#pragma once

#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 namespace std;

SparseMatrix::SparseMatrix(int r, int c)

{

row = r;

col = c;

sum = 0;

maxsum = r*c;

t = new Term[maxsum];

}

void SparseMatrix::transpose()

{

Term *cur = new Term[maxsum];

int *ColSize = new int[col];

int *RowNext = new int[row];

for (int i = 0; i < col; i++) ColSize[i] = 0;

for (int i = 0; i < row; i++) RowNext[i] = 0;

for (int i = 0; i < sum; i++) ColSize[t[i].col]++;//表示每一列的非零元素个数

RowNext[0] = 0;

for (int i = 1; i < col; i++) RowNext[i] = RowNext[i - 1] + ColSize[i - 1];//表示新矩阵中每一行的矩阵的前面的矩阵的个数

//进入转置操作

for (int i = 0; i < sum; i++)

{

int j = RowNext[t[i].col]++;

cur[j].value = t[i].value;

cur[j].col = t[i].row;

cur[j].row = t[i].col;

}

delete t;

t = cur;

}

void SparseMatrix::Store(int x, int i, int j)

{

t[sum].value = x;

t[sum].row = i;

t[sum].col = j;

sum++;

return;

}

void SparseMatrix::print()

{

for (int i = 0; i < sum; i++){

cout << t[i].value << " ";

}

cout << endl;

return;

}

void SparseMatrix::Add(SparseMatrix &b)//两个稀疏矩阵相加

{

if (col != b.col || row != b.row){

cout << "两个矩阵行列不同无法相加" << endl;

return;

}

int sa = 0;

int sb = 0;

Term *cur = new Term[maxsum];

int k = 0;

while (sa < sum || sb < b.sum)

{

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++;

}

else if (t[sa].row < b.t[sb].row)

{

cur[k].value = t[sa].value;

cur[k].row = t[sa].row;

cur[k].col = t[sa].col;

k++;

sa++;

}

else if (t[sa].row > b.t[sb].row)

{

cur[k].value = b.t[sb].value;

cur[k].row = b.t[sb].row;

cur[k].col = b.t[sb].col;

k++;

sb++;

}

else if (t[sa].col < t[sb].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 = b.t[sb].value;

cur[k].row = b.t[sb].row;

cur[k].col = b.t[sb].col;

k++;

sb++;

}

}

sum = k;

delete t;

t = cur;

return;

}

Term.h

#pragma once

class Term

{

friend class SparseMatrix;

private:

int col, row;

int value;

};

Term.cpp

#include"Term.h"

TridiagonalMatrix.h

#pragma once

class TridiagonalMatrix

{

public:

TridiagonalMatrix(int size);

void Store(int x, int i, int j);//向矩阵里存储一个元素int Retrieve(int i, int j);//返回矩阵中的一个元素

void print();

private:

int n;//矩阵非0元素个数

int *t;//用数组来存储矩阵

};

TridiagonalMatrix.cpp

#include"TridiagonalMatrix.h"

#include

using namespace std;

TridiagonalMatrix::TridiagonalMatrix(int size)

{

n = size;

t = new int[3 * n - 2];

}

void TridiagonalMatrix::Store(int x, int i, int j)

{

if (i<0 || j<0 || i >= n || j >= n)

{

cout << "三对角矩阵行列输入错误" << i << " " << j << endl;

return;

}

else if (x == 0)

{

cout << "三对角矩阵所添加的元素必须非零" << endl;

return;

}

else if (abs(i - j)>1)

{

cout << "三对角矩阵添加元素位置错误" << endl;

return;

}

switch (i - j)

{

case -1:

t[3 * j - 1] = x;

break;

case 0:

t[3 * j] = x;

break;

case 1:

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 << "三对角矩阵行列输入错误" << endl;

return -1;

}

else if (abs(i - j) <= 1)

{

return t[3 * j + (i - j)];

}

else{

return 0;

}

}

void TridiagonalMatrix::print()

{

for (int i = 0; i < 3 * n - 2; i++){

cout << t[i] << " ";

}

cout << endl;

return;

}

Test.cpp

#include

#include

#include

#include"TridiagonalMatrix.h"

#include"LowerTriangularMatrix.h"

#include"SparseMatrix.h"

#include"HashTable.h"

#include"ChainHashTable.h"

using namespace std;

int wei, num[100][100];

void c()

{

for (int i = 0; i < wei; i++)

for (int j = 0; j < wei; j++)

cin >> num[i][j];

}

int main()

{

int k = 0, l = 0;

/*三对角矩阵实验开始

测试数据4~10~3n-2

4

1 2 0 0

3 4 5 0

0 7 8 9

0 0 8 7

*/

cout << "请输入三对焦矩阵维数及容：" << endl;

cin >> wei;

c();

TridiagonalMatrix *TM = new TridiagonalMatrix(wei);

for (int i = 0; i < wei; i++)

for (int j = 0; j < wei; j++)

if (num[j][i] != 0)

TM->Store(num[j][i], j, i);

TM->print();

cout << "请输入要查询的元素的位置" << endl;

cin >> k >> l;

l = TM->Retrieve(k, l);

cout << "查询结果：" << l << endl;

cout << "***********************************************" << endl;

/*下三角矩阵实验开始

测试数据4~10~n*(n+1)/2

4

1 0 0 0

2 3 0 0

4 5 6 0

7 8 9 -1

*/

cout << "请输入下三角矩阵维数及容：" << endl;

k = 0, l = 0;

cin >> wei;

c();

LowerTriangularMatrix *LTM = new LowerTriangularMatrix(wei);

for (int i = 0; i < wei; i++)

for (int j = 0; j < wei; j++)

if (num[j][i] != 0)

LTM->Store(num[j][i], j, i);

cout << "请输入要查询的元素的位置" << endl;

cin >> k >> l;

l = LTM->Retrieve(k, l);

cout << "查询结果：" << l << endl;

cout << "***********************************************" << endl;

/*稀疏角矩阵实验开始

测试数据4 5

4 5

1 0 0 0 2

0 3 0 0 0

4 0 0

5 0

0 6 7 0 8

4 5

8 0 7 6 0

0 5 0 0 4

0 0 0 3 0

2 0 0 0 1

9 0 7 6 2

0 8 0 0 4

4 0 0 8 0

2 6 7 0 9

*/

cout << "请输入稀疏矩阵的维数及容：" << endl;

cin >> k >> l;

SparseMatrix *SM = new SparseMatrix(k, l);

for (int i = 0; i < k; i++)

for (int j = 0; j < l; j++)

{

cin >> num[i][j];

if (num[i][j])

SM->Store(num[i][j], i, j);

}

cout << "稀疏矩阵为： ";

SM->print();

SM->transpose();

cout << "转置后稀疏矩阵为： ";

SM->print();

SM->transpose();

cout << "重新转置后稀疏矩阵为： ";

cout << "矩阵相加开始，请输入要使用的矩阵维数及容:" << endl;

cin >> k >> l;

SparseMatrix *SM2 = new SparseMatrix(k, l);

for (int i = 0; i < k; i++)

for (int j = 0; j < l; j++)

{

cin >> num[i][j];

if (num[i][j])

SM2->Store(num[i][j], i, j);

}

cout << "新矩阵为： ";

SM2->print();

SM->Add(*SM2);

cout << "矩阵相加后为： ";

SM->print();

cout << "***********************************************" << endl;

cin.get();

system("pause");

/*使用散列表设计实现一个字典，假设关键字为整数且D为961，在字典中插入随机产生的500个不同的整数，实

现字典的建立和搜索操作。分别使用线性开型寻址和链表散列解决溢出

*/

k = 0; l = 0;

cout << "随即建立关键字为961,500个元素的散列表" << endl;

HashTable *BT = new HashTable(961);

for (int i = 0; i < 500;)

{

int j = rand() % 64435 + 1;

if (BT->Insert(j)) i++;

}

BT->print();

cout << "请输入要搜索的元素" << endl;

cin >> k;

l = BT->Search(k);

cout << "元素位置为： " << l << endl;

cout << "输入要插入的元素" << endl;

cin >> k;

BT->Insert(k);

BT->print();

cout << "实现溢出处理，插入所插入元素*2的元素" << endl;

BT->Insert(2 * k);

cout << "***********************************************" << endl; system("pause");

/*

链表散列解决溢出

*/

cout << "链表散列解决溢出,关键字为50，元素个数100" << endl; ChainHashTable *HT = new ChainHashTable(50);

for (int i = 0; i < 100;)

{

int j = rand() % 9661 + 1;

if (HT->Insert(j))

{

i++;

}

}

HT->print();

cout << "输入要插入的元素" << endl;

cin >> k;

HT->Insert(k);

HT->print();

cout << "实现溢出处理，插入所插入元素*2的元素" << endl;

HT->Insert(2 * k);

HT->print();

cout << "***********************************************" << endl; cin.get();

system("pause");

}

实验结果：