广州大学数据结构实验报告

数据结构实验一

一、实验目的：
1、线性表的链表实现：遍历、查找、插入、删除、翻转
2、栈的链式存储结构实现：入栈、出栈
3、队列的链式存储结构的实现：入队、出队
4、线性表、栈和队列的应用实现

二、使用仪器、器材
微机一台
操作系统：WIN10
编程软件：C++

三、实验内容及原理

1、线性表的链表实现：
（1）用随机函数生成 10 个 3 位整数（100~999），把这些整数存于链表中；
（2）输出链表的内容；
（3）读入一个整数，查看该整数是否在表中，若在，输出其位置（首位置为 1）；
（4）读入一个整数，以及要插入的位置，把该整数插入到链表中，输出链表的内容（要
求判断输入的位置是否合理）；
（5）读入一个整数，若该整数在链表里，删除该整数，输出链表的内容；
（6）把链表的内容翻转，输出链表的内容。

（1）第一步操作为单链表的初始化。通过生成一个新的空的单链表 L，并利用随机函数生产十个三位整数，用头插法的方法插入空的单链表中，先生成一个新的结点 p，随机生成一个范围为 100~999 三位数的整数存入结点 p 中，将新生成的结点 p 插入链表的表头，即结点 p 的指针指向头结点 L 的指针，修改头结点的指针，将头结点 L 的指针指向结点 p，完成一次插入操作，再将以上步骤重复九次，完成所有数据的入队操作，即完成单链表的初始化；
（2）第二步操作为单链表的遍历。先新生成一个结点 p,指向头结点的指针，首先需要
判断上一步进行的初始化操作是否发生错误，所生成的单链表是否为空表，若不为空表，
则对单链表进行遍历操作，输出此时结点 p 所指向的空间存储的值，再使结点 p 指向下一个空间，依次输出整个链表的数据，完成链表的遍历输出；
（3）第三步操作为单链表的查找。方法与遍历相似，增加一个计数器，记录下查找的位
置，将查找到的整数与读入的整数进行对比，若相等则输出计数器的数，即该整数在表
中的位置，若不相等，则继续进行遍历，对比单链表下一个结点中的整数，如此循环。
若循环结束仍未找到该整数，则查找失败，该整数不在表中；
（4）第四步操作为单链表的插入。由于单链表的结构特点，无法直接将整数插入到链表
的特定位置，需要通过建立新的指针 p，指向所需插入位置的前一结点的位置，为接下
来的插入操作做准备，同时需要判断插入的位置是否合理，再进行插入操作，建立一个
新的结点 s，将所需要的值赋值给结点 s，将结点 s 的指针指向结点 p 的指针，而结点 p的结点指向结点 s，完成插入操作；
（5）第五步操作为单链表的删除。先用查找的方法找到所需要删除的整数在单链表中的
位置，通过建立新的结点 q，结点 q 的指针指向所需删除位置的前一结点的位置，为接
下来的删除操作做准备，同时需要判断删除的位置是否合理，再进行删除操作，建立一
个新的结点 t，将结点 t 指向结点 q 的指针，临时保存被删结点的地址以备释放,而结点q 的指针指向结点 t 的指针，改变删除结点前驱结点的指针域，最后释放结点 t 的空间，完成删除操作；
（6）第六步操作为单链表的翻转。运用迭代的方法实现单链表的翻转操作，建立一个新
的的结点 p,其指针指向头节点的指针，运用 p 结点做迭代操作直到迭代到链尾。先新建一个结点 t 指向结点 p 的指针，暂存 p 的下一个地址，再新建一个结点 q 指向 NULL，结点 p 的指针指向结点 q，使 p 的指针指向前一个空间，结点 q 再指向结点 p，使新建的链表的头结点移动到 p，结点 p 指向结点 t，使结点 p 指向原始链表 p 的下一个空间，依次进行以上操作，直至迭代到链尾，完成翻转操作。

2、栈的链式存储结构实现
（1）用随机函数生成 10 个 3 位整数（100~999），把这些整数应用入栈操作存于堆栈中，在入栈接口处设置断点①，按“F5”启动调试，按“F10”逐句执行，直到数据
全部入栈。程序暂停时观察栈顶数据和栈顶位置；
（2）应用出栈操作输出堆栈的内容，在出栈接口处设置断点②，按“F5”启动调试，按
“F10”逐句执行，直到所有数据完全出栈，程序暂停时观察栈顶数据和栈顶位置
的变化；
（1）第一步操作为链栈的初始化和入栈。首先创建一个空的链栈，再将十个随机生成的
三位整数，依次执行入栈操作，新生成一个结点 p，将需要进行入栈操作的值赋
值给结点 p，再将结点 p 插入栈顶，最后修改栈顶执指针的值，完成一次入栈操
作，再重复以上步骤九次，完成整个链栈的初始化和入栈；
（2）第二步操作为链栈的输出和出站。建立一个新结点 p 指向栈顶指针，并输出栈顶指针指向的元素，再修改栈顶指针的值，使栈顶指针指向链栈的下一个空间，完成
一次出栈操作，再重复以上步骤九次，完成整个链栈的输出和出栈。

3、队列的链式存储结构的实现
（1）用随机函数生成 10 个 3 位整数（100~999），把这些整数应用入队操作存于队列中；
（2）应用遍历操作输出队列的内容；
（3）把队列的内容翻转，应用出队操作输出队列的内容。

（1）第一步操作为链队的初始化。通过生成一个新的空的链队 L，并利用随机函数生产十个三位整数，进行入队操作，依次将这十个三位整数入队到链队中，新建一个结点 p，
将需要入队的值赋值给结点 p，使结点 p 的指针指向 NULL，再将新结点 p 插入到队尾，最后修改队尾指针，使队列 s 的队尾指针指向结点 p，完成一次入队操作，再将以上操作重复九次，完成所有数据的入队操作，即完成链队的初始化；
（2）第二步操作为链队的遍历。新建一个结点 p，指向队头指针的下一个空间，判断结
点 p 是否为空，若为非空，输出结点 p 所指向的数据，再使结点 p 的指针指向下一个空间，依次输出整个链队的数据，完成链队的遍历输出；
（3）第三步操作为链队的翻转和出队。若队链为空或只有一个数据，则不需要翻转，直
接进行出队操作，否则先进行翻转操作，其原理与链表的翻转操作相似，运用迭代完成
整个队链的翻转，再将队链执行出队操作, 新建结点 p 指向队头指针的下一个空间，保
留并输出队头指针的下一个空间的元素，队头指针的所指向的下一个空间指向结点 p 的
指针，最后判断出队的元素是否为最后一元素，若是，则队尾指针重新赋值，指向头结
点，依次进行以上操作，直至完成整个队链的出队操作。

4、线性表、栈和队列的应用实现：
（1）用随机函数生成 10 个 3 位整数（100~999），把这些整数存于单链表中，然后读入一个整数，以该值为基准把单链表分割为两部分，所有小于该值的结点排在大于
或等于该值的结点之前。

一共有两种思路：
1）直接使用选择排序或冒泡排序直接将单链表进行一次排序，无论出现那种情况，所
有小于给定的整数的值的结点一定在大于或等于这个整数的右边；
2）先新建一个结点 p 指向头结点 L 的指针，判断结点 p 所指向的数据是否大于或等于给定的整数，若大于或等于，新建一个结点 q 指向结点 p，再对 q 进行迭代，寻找下一个小于给定整数的位置，若找到则交换结点 p 和结点 q 的数据，依次进行如上操作，直至到单链表的表尾，完成排列操作。

（2）假设一个字符串中可以包含三种括号：( )[ ]{}，且这三种括号可以按任意次序嵌套
使用（如：“…[…{…}…[…]…]…(…)” 为合法嵌套， “…[…{… )…[…]…]…(…)”为不合
法嵌套）。编写判别给定表达式中所含括号是否正确配对出现的算法，如果是合法
嵌套则返回为 true，如果是不符合法嵌套则返回为 false。

先初始化一个链栈，生成一个空的链栈，任意输入一个字符串，包括“( 、)、[ 、]、{、}”三种括号，从第一个字符开始对字符串的数据进行判断，一旦出现“(、[ 、{”三种类型的数据，便执行入栈操作，若出现“)、]、}”，则执行出站操作，判断出栈得到元素是否为对应的“(、[ 、{”，若不是则为不合法嵌套，若是则继续进行以上操作，直至将整个链栈的判断完，若仍无出现不合法嵌套现象，则该字符串为合法嵌套。

（3）用队列求解迷宫问题的最短路径
由题可得，假设一个迷宫，只有一个入口和一个出口，如果从迷宫的入口到达出口，
期间不出现前进方向错误，则得到一条最佳路线。
用一个二维数组 m[M+2][N+2]来表示迷宫。（M+2,N+2 是由于存在墙壁）
1)当数组元素 m[i][j]=1 (0≤i≤M+1,1≤j≤N+1)，表示该位置是墙壁，不能通行。
2)当数组元素 m[i][j]=0 (0≤i≤M+1,1≤j≤N+1)，表示该位置是通路，可以通行。
而数组的第 0 行、第 m-1 行、第 0 列、第 n-1 列，为迷宫的围墙。
该迷宫路径算法使用的搜索基本思想为回溯的思想，再结合顺序队列的结构进行相对应的操作，顺序队列具有先入先出的特征，通过该特点可以实现广度优先遍历的搜索策略，即同时对多个方向进行搜索，找出最佳路径，即最短路径。回溯法的基本思想为：从每一个位置出发，下一步都有四种选择（上右下左），先选择一个方向，如果该方向能够走下去，那么就往这个方向走，当前位置切换为下一个位置。如果不能走，那么换个方向走，如果所有方向都走不了，那么退出当前位置，到上一步的位置去，当前位置切换为上一步的位置。一致这样执行下去，如果当前位置是终点，那么结束。如果走过了所有的路径都没能到达终点，那么无解。但该实验中只需寻找最短的路径，从入口出发，首先将入口的元素放入队列中，检测哪些方向是可行的，将可行方位上的点都放入队列中，而再将队列上位于队头的元素出队。重复此操作，对队头元素依次进行出队并判断其各方位上是否存在可行的顶点并将该顶点的元素进行入队操作，直到找到最短的路径。
确定搜索的路径为从（x，y）到（X，Y），首先（x，y）进行进队操作，再将其坐标处的值赋值为-1以免重复搜索，当队列不为空且未找到最短路径时，先进行一次出队操作，循环搜索时循环扫描四个方位，把每一个可走的方块都插入队列中，如此循环搜索，最终当搜索的坐标等于出口的坐标时，即得到迷宫的最短路径。

四、实验过程原始数据记录
1、线性表的链表实现：
LinkList* CreateListHead()//初始化操作
{
LinkList *L, p;
int i;
srand((unsigned)time(0));//由时间确定随机序列，执行一次
L = (LinkList)malloc(sizeof(Node));//申请生成一个Node结构的新结点，使用动态分配内存的方式，并强制转换成LinkList的形式（确保）
L->next = NULL;
for (i = 0; i < 10; i++)//运用头插法
{
p = new Node;//生成一个新的结点p
p->data = rand() % 900 + 100;//随机生成一个范围为100~999三位数的整数
p->next = L->next;//将新生成的结点p的指针指向头结点L的指针
L->next = p;//将头结点L的指针指向结点p，完成插入操作
}
return L;
}

int ListPrint(LinkList L)//遍历操作
{
cout << “输出链表的内容：” << endl;
LinkList p = L->next;//新生成一个结点p,指向头结点的指针
if (p == NULL)//判断单链表是否为空表，若为空表不进行遍历操作
{
cout<<“为空表”<<endl;
}
while (p != NULL)//若不为空表，执行遍历操作，输出整个单链表所储存的数据
{
cout << p->data << endl;
p = p->next;
}
return 0;
}

int ListSearch(LinkList *L, int i)//查找操作
{
LinkList *p = L->next;//新生成一个结点p,指向头结点的指针
int j = 1;//计数器，记录下所查找的位置
while (p != NULL)//遍历查找整个单链表
{
if (p->data != i)
{
p = p->next;
j++;
}
else
{
break;
}
}
if (p != NULL)//若结点指针为非空，则证明查找成功，输出该整数在单链表中的位置
{
cout << p->data << “在表中的第” << j << “处” << endl;
}
else//否则查找失败，该整数不在单链表中
{
cout << i << “不在表中” << endl;
}
return 0;
}

int ListInsert(LinkList *L, int i,int j)//插入操作
{
LinkList *p, s;
p = L;//新生成一个结点p,指向头结点
int q = 1;
while (p && q < j) //寻找到所需插入位置的前一个结点的位置
{
p = p->next;
++q;
}
if (!p || q > j)//判断输入的位置是否合理
{
cout << “插入操作不合理，无法进行插入操作” << endl;
return 0;
}
s = (LinkList)malloc(sizeof(Node));//新生成一个node结构的新节点
s->data = i;//将所需要插入的值赋值给新生成的结点
s->next = p->next;//将结点s的指针指向结点p的指针
p->next = s;//将结点p的指针指向结点s
return 0;
}

int ListDelete(LinkList *L, int i)//删除操作
{
LinkList *p = L;//新生成一个结点p,指向头结点
int j = 0,k=0;
while (p != NULL)//寻找需要删除的整数的位置
{
if (p->data != i)
{
p = p->next;
j++;
}
else
{
break;
}
}
LinkList *q = L;//新生成一个结点q,指向头结点
while ((q->next) && (k < j-1))//寻找需要删除结点的前一个结点，将结点q的指向此结点
{
q = q->next;
k++;
}
if (!(q->next) || (k > j-1))//判断删除的位置是否合理
{
cout << “删除操作不合理，无法进行删除操作” << endl;
return 0;
}
LinkList t = (LinkList)malloc(sizeof(Node));//生成一个新的结点t
t = q->next;//临时保存被删结点的地址以备释放
q->next = t->next;//改变删除结点前驱结点的指针域
free(t);//释放删除结点的控件
return 0;
}

int ListTurn(LinkList *L)//翻转操作
{
LinkList *p, *q,*t;
p = L->next;
q = NULL;
while (p!=NULL)//一直迭代到链尾
{
t = p->next;//暂存p下一个地址
p->next = q;//p.next指向前一个空间
q = p;//新链表的头结点移动到p，扩长一步链表
p = t;//p指向原始链表p指向的下一个空间
}
L->next = q;
cout<<’\n’<<“翻转后的链表为：”<<endl;
ListPrint(L);
return 0;
}

2、栈的链式存储结构实现：
int Push(LinkStack *s,ElemType e)//入栈操作
{
LinkStack p;
p = (LinkStack)malloc(sizeof(StackNode));//新生成一个结点p
p->data = e;//将需要进行入栈操作的值赋值给结点p
p->next = s->top;//将新的结点p插入栈顶
s->top = p;//再修改栈顶执指针的值
return 0;
}

int Pop(LinkStack *s)//出栈操作
{
if (s->top== NULL)
{
cout << “为空栈” << endl;
return 0;
}
while (s->top != NULL)
{
LinkStack *p = InitStack();
p = s->top;//结点p指向栈顶指针
cout << p->data<<endl;//输出栈顶指针指向的元素
s->top = p->next;//修改栈顶指针的值
free§;
}
return 0;
}

3、队列的链式存储结构的实现
LinkQueue* InitQueue()//初始化操作
{
//构建一个空的链队
LinkQueue s = (LinkQueue)malloc(sizeof(LinkQueue));
s->front = s->rear = (QueuePtr*)malloc(sizeof(QueuePtr));
s->rear->next = NULL;
return s;
}

int EnterQueue(LinkQueue *s, int i)//入队操作
{
QueuePtr p=(QueuePtr)malloc(sizeof(QNode));//新建一个结点p
if (p == NULL)
{
cout << “内存分布失败” << endl;
exit(0);
}
p->data = i;//将需要入队的值赋值给结点p
p->next = NULL;//使结点p的指针指向NULL
s->rear->next = p;//将新结点p插入到队尾
s->rear = p;//修改队尾指针，使队列s的队尾指针指向结点p
return 0;
}

int DeQueue(LinkQueue *s )//出队操作
{
QueuePtr *p;
cout <<“出队列操作完毕,结果为：” << endl;
if (s->front==s->rear)
{
cout << “为空队列” << endl;
exit(0);
}
for (int i = 0; i < 10; i++)
{
p = s->front->next;//新建结点p指向队头指针的下一个空间
int e = p->data;//保留队头指针的下一个空间的元素
s->front->next = p->next;//队头指针的所指向的下一个空间指向结点p的指针
cout << e<<endl;
if (s->rear == p) //若出队的元素为最后一元素，是队尾指针重新赋值，指向头结点
{
s->rear = s->front;
}
free§;
}
return 0;
}

int TurnQueue(LinkQueue* s)//翻转操作
{
if (s->front == s->rear || s->front->next == NULL)
{
cout << “无需进行翻转操作，队列出队为：” << endl;
DeQueue(s);
}
QueuePtr *p,*q,*h;
p = s->front->next;
q = NULL;
while § {
h = p->next;
p->next = q;
q = p;
p = h;
}
s->front->next = q;
cout << “对队列的内容进行翻转操作” << endl;
DeQueue(s);
return 0;
}

void PrintQueue(LinkQueue *q)//遍历操作
{
QNode *p;
p = q->front->next;//新建一个结点p，指向队头指针的下一个空间
cout << “遍历操作输出队列:” << endl;
while §
{
cout << p->data << endl;
p = p->next;
}
cout << ‘\n’;
}

4、线性表、栈和队列的应用实现：
（1）
int LinkSort(LinkList L,int i)
{
//for (i = 0; i < 9; i++)
//{
// LinkList p = L->next;
// for (int j = 0; j < 9 - i ; j++)
// {
// if (p->data > p->next->data)
// {
// int e = p->data;
// p->data = p->next->data;
// p->next->data = e;
// }
// p = p->next;
// }
//}
for (int b = 0; b < 9; b++)
{
LinkList* p = L->next;
while (p!=NULL)
{
if (p->data >= i)
{
LinkList* q = p;
while (q != NULL)
{
int e = q->data;//暂存结点q的数据
if (q->data < i)
{
q->data = p->data;
p->data = e;
break;
}
q = q->next;
}
}
p = p->next;
}
}
ListPrint(L);
return 0;
}
（2）
bool jud(LinkStack *s)
{
string a;
cout << “请输入字符串：” << endl;
cin >> a;
int b = a.length();
for (int i = 0; i < b; i++)
{
switch (a[i])
{
case ‘(’:
case ‘{’:
case ‘[’:
Push(s, a[i]);
break;
case ‘)’:
if (Pop(s) != ‘(’)
{
return false;
}
break;
case ‘}’:
if (Pop(s) != ‘{’)
{
return false;
}
break;
case ‘]’:
if (Pop(s) != ‘[’)
{
return false;
}
break;
}
}
if (Pop(s))
{
return false;
}
}
（3）
int maze(int x, int y, int X, int Y) //搜索路径为:(x,y)->(X,Y)
{
int i, j, find = 0, t;
QuType q; //定义顺序队
q.front = q.rear = -1;
q.rear++;
q.data[q.rear].i = x;
q.data[q.rear].j = y; //(x,y)进队
q.data[q.rear].p = -1;
m[x][y] = -1; //将其赋值-1,以避免重复搜索
while (q.front != q.rear && !find) //队列不为空且未找到最短路径时循环
{
q.front++; //出队
i = q.data[q.front].i;
j = q.data[q.front].j;
if (i == X && j == Y) //找到了出口,输出路径
{
find = 1;
print(q, q.front); //调用print函数输出路径
return 1; //找到一条路径时返回1
}
for (t = 0; t < 4; t++) //循环扫描每个方位,把每个可走的方块插入队列中
{
switch (t)
{
case 0:
i = q.data[q.front].i - 1;
j = q.data[q.front].j;
break;
case 1:
i = q.data[q.front].i;
j = q.data[q.front].j + 1;
break;
case 2:
i = q.data[q.front].i + 1;
j = q.data[q.front].j;
break;
case 3:
i = q.data[q.front].i;
j = q.data[q.front].j - 1;
break;
}
if (m[i][j] == 0)
{
q.rear++; //将该相邻方块插入到队列中
q.data[q.rear].i = i;
q.data[q.rear].j = j;
q.data[q.rear].p = q.front; //指向路径中上一个方块的下标
m[i][j] = -1; //将其赋值-1,以避免回过来重复搜索
}
}
}
return 0;
}

五、实验结果及分析（自己搞）
实验结果：
无

实验分析：
无