一、实验目的：
1、线性表的链表实现：遍历、查找、插入、删除、翻转
2、栈的链式存储结构实现：入栈、出栈
3、队列的链式存储结构的实现：入队、出队
4、线性表、栈和队列的应用实现
二、使用仪器、器材
微机一台
操作系统：WinXP
编程软件：C++
三、实验内容及原理
1、线性表的链表实现：
（1）用随机函数生成10个3位整数（100~999），把这些整数存于链表中；
（2）输出链表的内容；
（3）读入一个整数，查看该整数是否在表中，若在，输出其位置（首位置为1）；
（4）读入一个整数，以及要插入的位置，把该整数插入到链表中，输出链表的内容（要求判断输入的位置是否合理）；
（5）读入一个整数，若该整数在链表里，删除该整数，输出链表的内容；
（6）把链表的内容翻转，输出链表的内容。
2、栈的链式存储结构实现
（1）用随机函数生成10个3位整数（100~999），把这些整数应用入栈操作存于堆栈中，在入栈接口处设置断点①，按“F5”启动调试，按“F10”逐句执行，直到数据全部入栈。程序暂停时观察栈顶数据和栈顶位置；
（2）应用出栈操作输出堆栈的内容，在出栈接口处设置断点②，按“F5”启动调试，按“F10”逐句执行，直到所有数据完全出栈，程序暂停时观察栈顶数据和栈顶位置的变化；
3、队列的链式存储结构的实现
（1）用随机函数生成10个3位整数（100~999），把这些整数应用入队操作存于队列中；
（2）应用遍历操作输出队列的内容；
（3）把队列的内容翻转，应用出队操作输出队列的内容。
4、线性表、栈和队列的应用实现：
（1）用随机函数生成10个3位整数（100~999），把这些整数存于单链表中，然后读入一个整数，以该值为基准把单链表分割为两部分，所有小于该值的结点排在大于或等于该值的结点之前。
（2）假设一个字符串中可以包含三种括号：( )[ ]{}，且这三种括号可以按任意次序嵌套使用（如：“…[…{…}…[…]…]…(…)” 为合法嵌套，“…[…{… )…[…]…]…(…)”为不合法嵌套）。编写判别给定表达式中所含括号是否正确配对出现的算法，如果是合法嵌套则返回为true，如果是不符合法嵌套则返回为false。
（3）用队列求解迷宫问题的最短路径
附：随机函数的使用（仅供参考）
#include “time.h” //用到时间函数
#include “math.h” // 用到随机函数
主程序：
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
生成10个随机数的循环体里：
rand() //随机生成一个0~32767的整数，可以嵌在转换公式或函数里
要求：
1.链式线性表、堆栈和队列可以带表头或不带表头，也可以设计为循环结构；
2.链表内容（结点数值）无序，可以重复，也可以不重复；
3.运行测试时，应尽量穷尽各种可能及组合，并在实验报告中展示输入及输出结果，选取具有代表性的使用截屏显示。
思路：
1，根据课本内容，用结构定义链表中每个节点的存储结构，用函数包装功能，用主函数调用。
四、实验过程原始数据记录
1、线性表的链表实现：
#include "pch.h"
#include <iostream>
#include<iostream>
#include<math.h>
#include<ctime>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
//单链表存储结构
typedef struct LNode {
ElemType data;
struct LNode *next;
int length;
}LNode, *LinkList;
//1,创建存储 n 个随机3位整数（100~999）的链表
Status CreateList(LinkList &L, int n)
{
L = new LNode;
L->next = NULL;//创建一个带头结点的单链表
L->length = n;
LNode *r = L;//尾指针指向头结点
for (int i = 0; i < n; ++i)
{
LNode *p = new LNode;
p->data = (rand() % 900 + 100);
p->next = NULL;
r->next = p;
r = p;
}
return OK;
}
// 2,输出链表内容
Status ShowElem(LinkList &L)
{
LNode *p = L->next;
cout << "以下按正序输出链表内容：" << endl;
for (int i = 0; i < L->length; i++)
{
cout << p->data << ends;
p = p->next;
}
cout << endl << endl;
return OK;
}
//3,单链表按值查找返回位置（首位为1）
Status LocateElem(LinkList &L)
{
LNode *p;
ElemType e=1;
while (e != 0)
{
int i = 1;
p = L->next;//使每次while循环前指针指向开头
cout << "请输入一个整数，我来告诉你它的位置^-^(退出请扣0)" << endl;
cin >> e;
if (!e) break;
while (p&&p->data != e)
{
p = p->next; //扫描直至p为空或data等于e
i++;
}
if (!p&&i > L->length)
{
cout << "错误！啥呀？链表没有" << endl;
}
else cout << "找到了，它在第" << i<<"位"<<endl;
}
return OK;
}
//4,单链表在某位置插入某数值
Status ListInitsert(LinkList &L)
{
LNode *p;
ElemType e = 1;
while (e != 0)
{
int i = 0, j = 0;
p = L;
cout << "请输入要安插的整数 (退出请扣0)：" << endl;
cin >> e;
if (!e) break;
cout << "请输入要安插的位置：" << endl;
cin >> i;
while (p && (j < i - 1)) { p = p->next; ++j; } //p指向第i-1个结点
if (!p || j > i - 1) cout << "错误！i大于 长度+1 或者i<1" << endl; //i>n+1或者i<1
else {
LNode *s = new LNode;
s->data = e;
s->next = p->next;
p->next = s;
L->length++;
cout << "插入成功！" << endl;
ShowElem(L);
}
}
return OK;
}
//5,链中元素的删除
Status ListDelete(LinkList &L)
{
ElemType e = 1;
while (e != 0)
{
LNode *p = new LNode;
p = L;
cout << "请输入要删除的整数 (退出请扣0)：" << endl;
cin >> e;
if (!e) break;
while ((p->next)&&p->next->data != e)
{
p = p->next;
}
if (!p->next) { cout << "错误！啥呀？链表没有" << endl; }
else
{
LNode *q = new LNode;
q = p->next;
p->next = q->next;
delete q;
cout << "删除成功！" << endl;
L->length--;
ShowElem(L);
}
}
return OK;
}
//6，倒序输出
Status AntiShow(LinkList &L,int i)
{
LNode *p = L->next;
int j=1;
while (j != i )
{
j++;
p = p->next;
}
cout << p->data << ends;
i--;
AntiShow(L, i);
return OK;
}
int main()
{
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
LinkList List;
if (CreateList(List, 10)) cout << "成功！已生成含有10个随机整数的链表！" << endl;
else cout << "失败！无法生成链表！" << endl;
if (!ShowElem(List)) cout << "失败！无法正序输出链表内容！";
LocateElem(List);
ListInitsert(List);
ListDelete(List);
AntiShow(List,List->length);
}
2、栈的链式存储结构实现
#include "pch.h"
#include <iostream>
using namespace std;
#include"math.h"
#include"time.h"
#define OK 1
#define ERROR 0
typedef int Status;
typedef int ElemType;
//链栈存储结构
typedef struct StackNode {
ElemType data;
struct StackNode *next;
}StackNode, *LinkStack;
//创建存有10个随机整数的链栈
Status InitStack(LinkStack &S)
{
S = NULL;
cout << "元素入栈：" << ends;
for (int i = 0; i < 10; ++i)
{
StackNode *p = new StackNode;
p->data = (rand() % 900 + 100);
p->next = S;
S= p;//修改栈顶指针为p
cout << p->data << ends;
}
cout << endl;
return OK;
}
//出栈所有元素
Status Pop(LinkStack &S)
{
if (S == NULL) return ERROR;
ElemType e = S->data; //栈顶元素给e
StackNode *p = S; //用p临时保存栈顶元素空间
S = S->next; //指向新栈顶
cout << "已删除 " << p->data << endl;
delete p; //释放原栈顶
Pop(S); //递归把所有元素出栈
return OK;
}
int main()
{
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
LinkStack S;
InitStack(S);
Pop(S);
}
3、队列的链式存储结构的实现
#include "pch.h"
#include <iostream>
using namespace std;
#include<math.h>
#include<ctime>
#define OK 1
#define ERROR 0
typedef int Status;
typedef int QElemType;
typedef int SElemType;
//***************************队列链式存储结构
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue;
//链栈存储结构
typedef struct StackNode {
SElemType data;
struct StackNode *next;
}StackNode, *LinkStack;
//创建空栈
Status EmStack(LinkStack &S)
{
S = NULL;
return OK;
}
//出栈
SElemType Pop(LinkStack &S)
{
SElemType se;
if (S == NULL) return ERROR;
se = S->data; //栈顶元素给e
StackNode *p = S; //用p临时保存栈顶元素空间
S = S->next; //指向新栈顶
delete p; //释放原栈顶
return se;
}
//********************************创建含有10个随机整数的队列
Status InitQueue(LinkQueue &Q)
{
Q.front = Q.rear = new QNode;
Q.front->next = NULL;
for (int i = 0; i < 10; ++i)
{
QNode *p = new QNode;
p->data = (rand() % 900 + 100);
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
}
cout << "创建队列成功！" << endl;
return OK;
}
//*************************************遍历输出队列内容
Status ShowElemType(LinkQueue &Q)
{
QNode *p = new QNode;
p = Q.front;
cout << "遍历输出队列内容: " << endl;
while ( p->next!=NULL )
{
cout << p->next->data << ends;
p = p->next;
}
cout << endl;
return OK;
}
//***********************************用栈翻转队列
Status AtQueue(LinkQueue &Q,LinkStack &s)
{
StackNode *pS = new StackNode;
if (Q.front == Q.rear) { cout << "翻转完成" << endl; return ERROR; }
QNode *pQ = Q.front->next; //p指向队头
Q.front->next = pQ->next; //修改头结点指针域
if (Q.rear == pQ) Q.rear = Q.front; //最后元素被删，尾指针指向队头
pS->data=pQ->data; //栈新结点等于头结点
pS->next = s; //新节点指向栈顶
s = pS; //修改栈顶为p
delete pQ;
AtQueue(Q, s);
while (s!=NULL)
{
QNode *pQ2 = new QNode;
pQ2->data = Pop(s);
pQ2->next = NULL;
Q.rear->next = pQ2;
Q.rear = pQ2;
}
return OK;
}
//*****************************出队
Status DeQueue(LinkQueue &Q)
{
if (Q.front == Q.rear) { cout <<endl<< "全部元素出队完成" << endl; return ERROR; }
QNode *pQ = Q.front->next; //p指向队头
cout << pQ->data << ends;
Q.front->next = pQ->next; //修改头结点指针域
if (Q.rear == pQ) Q.rear = Q.front; //最后元素被删，尾指针指向队头
delete pQ;
DeQueue(Q);
return OK;
}
int main()
{
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
LinkQueue queue;
LinkStack s;
EmStack(s);
InitQueue(queue);
ShowElemType(queue);//遍历显示
AtQueue(queue, s); //翻转
DeQueue(queue);//出队
delete s,queue;
}
4、线性表、栈和队列的应用实现：
（1）用随机函数生成10个3位整数（100~999），把这些整数存于单链表中，然后读入一个整数，以该值为基准把单链表分割为两部分，所有小于该值的结点排在大于或等于该值的结点之前。
#include "pch.h"
#include <iostream>
#include<math.h>
#include<ctime>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int LElemType;
typedef int SElemType;
typedef int QElemType;
//单链表存储结构
typedef struct LNode {
LElemType data;
struct LNode *next;
LNode *LRear;
int length;
}LNode, *LinkList;
//创建空表
Status EmList(LinkList &L)
{
L = new LNode;
L->next = NULL;
L->LRear = L;
L->length = 0;
return OK;
}
//链表的存储
Status StoreElem(LinkList &L,LElemType &e)
{
LNode *p = new LNode;
p->data = e;
p->next = NULL;
L->LRear->next = p;
L->LRear = p;
L->length++;
return OK;
}
// 输出链表内容
Status ShowElem(LinkList &L)
{
LNode *p = L->next;
cout << "以下按正序输出链表内容：" << endl;
for (int i = 0; i < L->length; i++)
{
cout << p->data << ends;
p = p->next;
}
cout << endl << endl;
return OK;
}
//************************************************创建存储 n 个随机3位整数（100~999）的链表，某值为基准把单链表分割为两部分
Status CreateList(LinkList &L)
{
for (int i = 0; i < 10; ++i)
{
int j = rand() % 900 + 100;
StoreElem(L,j);
}
ShowElem(L);
LElemType measure;
cout << "请输入一个整数，我们会将这个劈成两半" << endl;
cin >> measure;
LNode *flag = L;
for(int i=0,j=10;i<j;i++)
{
if (flag->next->data >= measure)
{
L->LRear->next = flag->next;
L->LRear = flag->next;
flag->next = flag->next->next;
L->LRear->next = NULL;
}
else flag = flag->next;
}
ShowElem(L);
return OK;
}
int main()
{
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
LinkList list;
EmList(list);
CreateList(list);
}
（2）假设一个字符串中可以包含三种括号：( )[ ]{}，且这三种括号可以按任意次序嵌套使用（如：“…[…{…}…[…]…]…(…)” 为合法嵌套，“…[…{… )…[…]…]…(…)”为不合法嵌套）。编写判别给定表达式中所含括号是否正确配对出现的算法，如果是合法嵌套则返回为true，如果是不符合法嵌套则返回为false。
#include "pch.h"
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef char SElemType;
typedef char QElemType;
//链栈存储结构
typedef struct StackNode {
SElemType data;
struct StackNode *next;
}StackNode, *LinkStack;
//创建空栈
Status EmStack(LinkStack &S)
{
S = NULL;
return OK;
}
//队列链式存储结构
typedef struct QNode
{
QElemType data;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue;
//出栈
SElemType Pop(LinkStack &S)
{
SElemType se;
if (S == NULL) return ERROR;
se = S->data; //栈顶元素给e
StackNode *p = S; //用p临时保存栈顶元素空间
S = S->next; //指向新栈顶
delete p; //释放原栈顶
return se;
}
//入栈
Status Getstack(LinkStack &S, SElemType es)
{
StackNode *p = new StackNode;
p->data = es;
p->next = S;
S = p;//修改栈顶指针为p
return OK;
}
//********************************创建队列
Status InitQueue(LinkQueue &Q, char *a)
{
Q.front = Q.rear = new QNode;
Q.front->next = NULL;
cout << "创建队列 : " << ends;
for (int i = 0; i < 8; ++i)
{
QNode *p = new QNode;
p->data = a[i];
cout << p->data<<ends;
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
}
cout << endl;
return OK;
}
//*****************************出队，并返回值
Status DeQueue(LinkQueue &Q,QElemType &eq)
{
if (Q.front == Q.rear) return ERROR;
QNode *pQ = Q.front->next; //p指向队头
eq = pQ->data;
Q.front->next = pQ->next; //修改头结点指针域
if (Q.rear == pQ) Q.rear = Q.front; //最后元素被删，尾指针指向队头
delete pQ;
return OK;
}
//匹配
bool Matching(LinkQueue &Q, LinkStack &s)
{
QElemType eq;
int flag = 1;
while (DeQueue(Q, eq)&&flag)
{
switch (eq)
{
case '(':
case '[':
case'{':
Getstack(s,eq);
break;
case ')':
if (s->data == '(') Pop(s);
else(flag = 0);
break;
case ']':
if (s->data == '[') Pop(s);
else(flag = 0);
break;
case '}':
if (s->data == '{') Pop(s);
else(flag = 0);
break;
}
}
if (flag == 1) return true;
else return false;
}
int main()
{
char a[8] = {'[','{','}','[',']',']','(',')' };
char b[8] = {'[','{',')','[',']',']','(',')' };
LinkQueue qa;
LinkQueue qb;
LinkStack s;
EmStack(s);
InitQueue(qa, a);
if (Matching(qa, s)) cout << "该字符串为合法嵌套" << endl;
else cout<< "该字符串为不合法嵌套" << endl;
InitQueue(qb, b);
if (Matching(qb, s)) cout << "该字符串为合法嵌套" << endl;
else cout << "该字符串为不合法嵌套" << endl;
}
（3）用队列求解迷宫问题的最短路径
#include "pch.h"
#include <iostream>
using namespace std;
#define OK 1
#define ERROR 0
typedef int Status;
typedef int QElemType;
//队列链式存储结构
typedef struct QNode
{
QElemType idata;
QElemType jdata;
struct QNode *next;
}QNode, *QueuePtr;
typedef struct
{
QueuePtr front;//队头指针
QueuePtr rear;//队尾指针
}LinkQueue;
//创建空队列
Status InitQueue(LinkQueue &Q)
{
Q.front = Q.rear = new QNode;
Q.front->next = NULL;
return OK;
}
//入队
Status InQueue(LinkQueue &Q, QElemType i, QElemType j)
{
QNode *p = new QNode;
p->idata = i;
p->jdata = j;
p->next = NULL;
Q.rear->next = p;
Q.rear = p;
return OK;
}
//出队
Status DeQueue(LinkQueue &Q, int e)
{
if (Q.front == Q.rear) return ERROR;
QNode *pQ = Q.front->next; //p指向队头
Q.front->next = pQ->next; //修改头结点指针域
if(e==1) //若是迷宫没有路，则e==0，不输出值
cout << "a[ " << pQ->idata << " ][ " << pQ->jdata << " ]---->"<<endl;
if (Q.rear == pQ) Q.rear = Q.front; //最后元素被删，尾指针指向队头
delete pQ;
DeQueue(Q,e);
return OK;
}
//求迷宫最短路径
Status LookFor(LinkQueue &Load,int *a, QElemType i, QElemType j)
{
if (i == 5&&j == 5)
{
InQueue(Load, i, j);
return OK;
}
if (a[(j + 1) + i * 6] == 0&&j!=5)
{
a[(j + 1) + i * 6] = 1;
InQueue(Load, i, j);
LookFor(Load, a, i, j + 1);
}
else if(a[j + (i+1 )* 6] == 0&&i!=5)
{
a[j + (i + 1) * 6] = 1;
InQueue(Load, i, j);
LookFor(Load, a, i+1, j );
}
else if (a[(j - 1) + i * 6] == 0&&j!=0)
{
a[(j - 1) + i * 6] = 1;
InQueue(Load, i, j);
LookFor(Load, a, i , j-1);
}
else if (a[j + (i - 1) * 6] == 0&&i!=0)
{
a[j + (i - 1) * 6] = 1;
InQueue(Load, i, j);
LookFor(Load, a, i, j - 1);
}
return OK;
}
//输出迷宫
void ShowMaze(int *a)
{
cout << "该迷宫：" << endl;
for (int i = 0; i < 6; i++)
{
for (int j = 0; j < 6; j++)
cout << a[i * 6 + j] << ends;
cout << endl;
}
}
int main()
{
LinkQueue Load;
InitQueue(Load);
int flag = 1;//用来控制出队时是否要输出值
int a[6*6]= //创建迷宫，1为障碍，0为道路
{
0,0,0,1,0,0,
1,1,0,0,0,1,
1,1,0,0,0,1,
0,0,0,1,0,1,
0,1,1,1,0,1,
0,0,0,0,0,0
};
ShowMaze(a);
cout << "该迷宫路径：" << endl;
LookFor(Load, a, 0, 0);
if (Load.rear->idata != 5 || Load.rear->jdata != 5) //判断是否达到终点
{
flag = 0; cout << "错误，没有路" << endl; DeQueue(Load, flag);
}
else
{
flag = 1;
cout << endl;
DeQueue(Load, flag);
}
cout << endl << endl;
int a0[6 * 6] = //去不了终点的迷宫
{
0,1,1,1,1,1,
0,0,0,1,1,1,
1,0,0,0,0,1,
1,0,1,1,0,1,
1,1,1,1,0,1,
1,1,1,1,1,0
};
ShowMaze(a0);
LookFor(Load, a0, 0, 0);
if (Load.rear->idata != 5 || Load.rear->jdata != 5)
{
flag = 0; cout << "错误，没有路" << endl; DeQueue(Load, flag);
}
else
{
cout << "该迷宫路径：" << endl;
flag = 1;
cout << endl;
DeQueue(Load, flag);
}
cout << endl << endl;
int a2[6 * 6] = //全是1的迷宫
{
1,1,1,1,1,1,
1,1,1,1,1,1,
1,1,1,1,1,1,
1,1,1,1,1,1,
1,1,1,1,1,1,
1,1,1,1,1,1
};
ShowMaze(a2);
cout << "该迷宫路径：" << endl;
LookFor(Load, a2, 0, 0);
if (Load.rear->idata != 5 || Load.rear->jdata != 5)
{
flag = 0; cout << "错误，没有路" << endl; DeQueue(Load, flag);
}
else
{
flag = 1;
cout << endl;
DeQueue(Load, flag);
}
cout << endl << endl;
int a1[6 * 6] = //全是0的迷宫
{
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0,
0,0,0,0,0,0
};
ShowMaze(a1);
cout << "该迷宫路径：" << endl;
LookFor(Load, a1, 0, 0);
if (Load.rear->idata != 5 || Load.rear->jdata != 5)
{
flag = 0; cout << "错误，没有路" << endl; DeQueue(Load, flag);
}
else
{
flag = 1;
cout << endl;
DeQueue(Load,flag);
}
cout << endl << endl;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
