数据结构实验报告和程序代码.docx

数据结构实验报告和程序代码.docx

《数据结构实验报告和程序代码.docx》由会员分享，可在线阅读，更多相关《数据结构实验报告和程序代码.docx（111页珍藏版）》请在冰豆网上搜索。

数据结构实验报告和程序代码

课程实验报告

课程名：

数据结构

学院：

信息工程学院系计算机科学与技术系

专业：

计算机科学与技术

班级：

计算机科学与技术185班

学号：

xxxxxxxx

姓名：

xx

任课教师：

任燕

授课学期：

2019年~~~~2020年一学期

南昌大学实验报告

实验一单链表队列

学生姓名：

xx学号：

xxxxxxxx专业班级：

计算机185

实验类型：

□验证□综合□设计□创新实验日期：

2019-10-10实验成绩：

1、实验项目名称

用顺序表实现学生健康情况登记表。

2、实验目的

1.掌握非循环队列的逻辑结构、存储结构、操作。

2.利用单链表实现非循环队列，用C++编写程序实现简单的控制台交互界面。

3、实验基本原理

1.非循环的队列特点是先进先出。

2.使用队头指针front和队尾指针rear来进行对队列的元素的插入删除操作。

4、主要仪器设备及耗材

PC微型计算机，C++集成开发环境编译器。

5、实验步骤（完整内容见光盘）

1.问题分析与程序设计

（1）问题分析

非循环队列是一个有着特定操作的单链表，特点只能操作队头和队尾的元素。

应当允许进行队尾元素的插入，队头元素的删除，打印队列等基本操作。

（2）算法原理

利用单链表可以创建一个理论上无限长的单链表队列。

队尾元素插入的对应操作是生成一个新的节点，类比于单链表的元素插入操作，将新节点插入队列末尾。

队头元素的删除则类比于单链表的删除元素的操作，将队头节点内存释放，队头指针指向下一个节点。

2.代码

1.#include   

2.#include   

3.#include   

4.  

5.using namespace std;  

6.  

7.#define OK 1  

8.#define ERROR 0  

9.#define TRUE 1  

10.#define FALSE 0  

11.  

12.typedef int Status;  

13.struct ElemType {  

14.    string name;  

15.    int value;  

16.};  

17.  

18.typedef struct QNode {  

19.    ElemType data;  

20.    QNode *next;  

21.} QNode, *QueuePtr;  

22.  

23.struct LinkQueue {  

24.    QueuePtr rear, front;  

25.    int length;  

26.};  

27.//--------------------基本操作的函数  

28.  

29.//创建一个队列  

30.Status InitQueue（LinkQueue &Q） {  

31.    QueuePtr baseNode;  

32.    baseNode = new（QNode）;  

33.        Q.front = baseNode;//头  

34.        Q.rear = baseNode;//尾  

35.        Q.length = 0;  

36.        return OK;  

37.}  

38.  

39.//销毁一个队列  

40.Status DestroyQueue（LinkQueue &Q） {  

41.    if （!

Q.front）  

42.        return ERROR;  

43.    QueuePtr cur_Node, next_Node;  

44.    cur_Node = Q.front->next;  

45.    next_Node = cur_Node->next;  

46.    while （cur_Node !

= Q.rear） {  

47.        delete （cur_Node）;  

48.        cur_Node = next_Node;  

49.        next_Node = cur_Node->next;  

50.    }//释放所有结点内存  

51.    Q.rear = NULL;  

52.    Q.front = NULL;  

53.    return OK;  

54.}  

55.  

56.//清空一个队列  

57.Status ClearQueue（LinkQueue &Q） {  

58.    if （!

Q.front）  

59.        return ERROR;  

60.    QueuePtr cur_Node, next_Node, firstNode;  

61.    cur_Node = Q.front->next;  

62.    next_Node = cur_Node->next;  

63.    while （cur_Node !

= Q.rear） {  

64.        delete （cur_Node）;  

65.        cur_Node = next_Node;  

66.        next_Node = cur_Node->next;  

67.    }//释放所有结点内存  

68.    if （firstNode = new（QNode）） {  

69.        Q.front = firstNode;//头  

70.        Q.rear = firstNode;//尾  

71.        Q.length = 0;  

72.    }  

73.    return OK;  

74.}  

75.  

76.//查询队列是否为空  

77.Status QueueEmpty（LinkQueue Q） {  

78.    if （Q.front == Q.rear || Q.length == 0） return TRUE;  

79.    else return FALSE;  

80.}  

81.  

82.//返回队列的长度  

83.int QueueLength（LinkQueue Q） {  

84.    return Q.length;  

85.}  

86.  

87.//获取队头元素  

88.Status GetHead（LinkQueue Q, ElemType &e） {  

89.    if （!

Q.front && Q.length !

= 0） return ERROR;  

90.    e.name = Q.front->next->data.name;  

91.    e.value = Q.front->next->data.value;  

92.    return OK;  

93.}  

94.  

95.//插入新元素  

96.Status EnQueue（LinkQueue &Q, ElemType e） {  

97.    if （!

Q.rear）return ERROR;  

98.    QueuePtr newNode;  

99.    newNode = new（QNode）;  

100.    newNode->data.name = e.name;  

101.    newNode->data.value = e.value;  

102.    Q.rear->next = newNode;  

103.    Q.rear = newNode;  

104.    Q.length++;  

105.    return OK;  

106.}  

107.  

108.//删除队头元素（若队列不为空）,用e返回队头元素  

109.Status DeQueue（LinkQueue &Q, ElemType &e） {  

110.    if （Q.length == 0）return ERROR;  

111.    QueuePtr cur_Node;  

112.    cur_Node = Q.front->next;  

113.    e.name = cur_Node->data.name;  

114.    e.value = cur_Node->data.value;  

115.    Q.front = cur_Node->next;  

116.    delete （cur_Node）;  

117.    return OK;  

118.}  

119.  

120.// 打印所有元素  

121.Status visitQueue（LinkQueue Q） {  

122.    if （Q.front == Q.rear）  

123.        return ERROR;  

124.    QueuePtr cur_Node;  

125.    cur_Node = Q.front->next;  

126.    int i = 1;  

127.    while （cur_Node !

= Q.rear） {  

128.        cout << "结点Node" << i << "的" << endl  

129.             << "name:

" << cur_Node->data.name << endl  

130.             << "value:

" << cur_Node->data.value << endl;  

131.        i++;  

132.        cur_Node = cur_Node->next;  

133.    }  

134.    cout << "结点Node" << i << "的" << endl  

135.         << "name:

" << cur_Node->data.name << endl  

136.         << "value:

" << cur_Node->data.value << endl;   

137.    return OK;  

138.}  

139.  

140.int main（） {  

141.    ElemType var,U_var;  

142.    LinkQueue Q;  

143.    int exit_code = -1;  

144.    while （exit_code !

= 10） {  

145.        Sleep（1000）;  

146.        cout << "1.创造一个队列" << endl  

147.             << "2.销毁一个队列" << endl  

148.             << "3.清空队列" << endl  

149.             << "4.查询队列是否为空" << endl  

150.             << "5.返回队列的长度" << endl  

151.             << "6.返回队头元素" << endl  

152.             << "7.插入队尾元素" << endl  

153.             << "8.删除队头元素" << endl  

154.             << "9.打印队列所有元素" << endl  

155.             << "10.退出" << endl  

156.             << "输入对应的操作码选择对应的功能!

" << endl;  

157.        while （!

（cin >> exit_code） || cin.fail（） || exit_code > 10） {  

158.            cin.clear（）;  

159.            cin.sync（）;  

160.            cout << "输入错误，请重新输入！

" << endl;  

161.        }  

162.        switch （exit_code） {  

163.            case 1:

164.                if （InitQueue（Q）） {  

165.                    var.name = "张三";  

166.                    var.value = 1;  

167.                    EnQueue（Q, var）;  

168.                    var.name = "李四";  

169.                    var.value = 2;  

170.                    EnQueue（Q, var）;  

171.                    var.name = "王五";  

172.                    var.value = 3;  

173.                    EnQueue（Q, var）;  

174.                }  

175.                { if （visitQueue（Q））cout << "操作成功！

" << endl; };  

176.                break;  

177.            case 2:

178.                if （DestroyQueue（Q）） cout << "操作成功！

" << endl;  

179.                break;  

180.            case 3:

181.                if （ClearQueue（Q）） cout << "操作成功！

" << endl;  

182.                break;  

183.            case 4:

184.            if （QueueEmpty（Q）） cout << "队列为空！

" << endl;  

185.            else cout<<"队列不为空！

"<

186.            break;  

187.            case 5:

188.                if （QueueLength（Q）） cout << "Q.length is :

" << QueueLength（Q） << endl << "操作成功！

" << endl;  

189.                break;  

190.            case 6:

191.                if （GetHead（Q, var）） {  

192.                    cout << "操作成功！

" << endl  

193.                         << "Head.name is:

" << var.name<

194.                         << "Head.value is:

" << var.value << endl;  

195.                }  

196.                break;  

197.            case 7:

198.                cout<<"input name:

"<

199.                cin>>U_var.name;  

200.                cout<<"input value:

"<

201.                cin>>U_var.value;  

202.                if （EnQueue（Q,U_var）） cout << "操作成功！

" << endl;  

203.                break;  

204.            case 8:

205.                if （DeQueue（Q,var）） cout << "操作成功！

" << endl  

206.                                         << "Head.name is:

" << var.name<

207.                                         << "Head.value is:

" << var.value << endl;  

208.                break;  

209.            case 9:

210.                if （visitQueue（Q）） {  

211.                    cout << "操作成功！

" << endl;}  

212.                break;  

213.        }  

214.    }  

215.    return 0;  

216.}  

6、实验数据及处理结果

1.初始菜单页面

2.创建一个队列

3.查队列是否为空

4.返回队列长度

5.返回队头元素

6.插入队尾元素

7.删除队头元素

7、思考讨论题或体会或对改进实验的建议

利用队列的特性可以设计一个基于队列原理的银行/医院领号排队系统。

利用非循环队列模拟银行用户的排队情况，可以借此分析银行的业务办理高峰期，用户平均排队时间等信息，可以方便银行进行业务优化。

可以看见，掌握了数据结构的基本方法，我们还要善于运用创新思维，学以致用，结合生活实际把书本上抽象的知识具体起来。

八、参考资料

《数据结构》

南昌大学实验报告

实验二顺序数组

学生姓名：

xx学号：

xxxxxxxx专业班级：

计算机185班

实验类型：

□验证□综合□设计□创新实验日期：

2019-10-17实验成绩：

1、实验项目名称

自定义数组及其常规操作

2、实验目的

1.用自己定义的数据类型构造一个新数据类型的顺序数组。

2.实现顺序数组的基本操作：

初始化，赋值，取值，删除。

3、实验基本原理

1.顺序数组可以看成一个定长的顺序链表。

在确定了里面数据的约束关系后就可以为数组分配内存空间并进行相应的操作。

四、主要仪器设备及耗材

PC微型计算机，C++集成开发环境编译器。

五、实验步骤（完整内容见光盘）

1.问题分析：

本次实验只需要实现数组的几个基本操作：

初始化，赋值，取值，删除。

由于使用了不定参数传参方式，所以不方便设计用户交互界面，只能实现基本功能。

2.代码

1.#define MAX_ARRAY_DIM 8  

2.#define ERROR 0  

3.#define OVERFLOW -2  

4.#define OK 1  

5.typedef int Status;  

6.  

7.typedef int ElemType;  

8.typedef struct {  

9.    ElemType *base;  

10.    int dim;  

11.    int *bounds;  

12.    int *constants;  

13.}Array;  

14.Status Array_Operation:

:

InitArray（Array &A, int dim, ...） {  

15.    if（dim <1||dim > MAX_ARRAY_DIM） return ERROR;  

16.    A.dim = dim;  

17.    A.bounds = new （int）（dim）;  

18.    if（!

A.bounds） exit（OVERFLOW）;  

19.    int elemtotal = 1;  

20.    va_list ap;  

21.    va_start（ap,dim）;  

22.    for （int i = 0;i

23.        A.bounds[i]= va_arg（ap,int）;  

24.        if（A.bounds[i]<0） return OVERFLOW;  

25.        elemtotal*=A.bounds[i];  

26.    }  

27.    va_end（ap）;  

28.   A.base = （ElemType *）malloc（elemtotal* sizeof（ElemType））;  

29.   //A.base = new （ElemType）（elemtotal）;  

30.    if（!

A.base） exit（OVERFLOW）;  

31.    A.constants = new（int）（dim）;  

32.    if（!

A.constants） exit（OVERFLOW）;  

33.    A.constants[dim-1] = 1;  

34.    for （int  i = dim-2;i>=0;--i）{  

35.        A.constants[i] = A.bounds[i+1]*A.constants[i+1];  

36.    }  

37.    return OK;  

38.}  

39.Status Array_Operation:

:

DestroyArray（A