实验一 链式存储结构的基本操作_链式存储实验

广州大学学生实验报告

开课实验室：计算机科学与工程实验（电子楼418A） 2019年4月27日
学院 计算机科学与教育软件学院 年级、专业、班 计算机科学与技术172班 姓名 xxx 学号 170610xxxx
实验课程名称 数据结构实验 成绩
实验项目名称 实验一 链式存储结构的基本操作 指导老师 xxx
一、实验目的
掌握链式存储结构的定义及基本操作
二、使用仪器、器材
微机一台
操作系统：Win10
编程软件：C++
三、实验内容及原理
线性表的链表实现：遍历、查找、插入、删除、翻转
栈的链式存储结构实现：入栈、出栈
队列的链式存储结构的实现：入队、出队
栈和队列的简单应用：编写函数，判断给定的字符串是否回文。

四、实验过程原始数据记录

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

所采取的方案：

1. 链式线性表带表头，非循环结构；
2. 链表内容为无序；
3. 链表内容（结点数值）可以重复，也可以不重复
   Listmain.cpp
   #include “pch.h”
   #include
   #include"header.h"
   using namespace std;

int main()
{

LinkNode *Link;
InitList(Link);
time_t t;   // 定义时间变量
srand((unsigned)time(&t));  //由时间确定随机序列，执行一次
int aa[10];
for (int i = 0; i <10; i++)
{
	int a = rand()%900+100;
	aa[i]=a;
}
CreateListF(Link, aa, 10);
cout << "数据插入成功"<<endl;
cout<<"随机生成的数组为："<<endl;
DispList(Link);
bool flag;
int i, e;
cout << "如果要判断一个数是否在链表中，请输入任意非零数进入判断，否则跳过该判断请输入0:";
cin >> flag;
while (flag) {
	cin.clear();
	cout<<"请输入要查找的数据："<<endl;
	cin>>e;
	LocateElem(Link, i, e);
	if (i!=0&&i!=11)
	{
		cout << "该查找数据的位置为：";
		cout << i;
		cout << endl;
	}
	else cout << "该查找数据不在生成数列里"<<endl;
	cout << "如果要判断一个数是否在链表中，请输入任意非零数进入判断，否则跳过该判断请输入0:";
	cin >> flag;
}
cout << "如果要插入一个数进入链表中，请输入任意非零数进入插入，否则跳过该次插入请输入0:";
cin >> flag;
while (flag) {
	cin.clear();
	int ii, ee;
	cout<<"请输入要插入数据的位置：" << endl;
	cin>>ii;
	cout<<"请输入要插入数据的值：" << endl;
	cin>>ee;
	bool flag1=ListInsert(Link, ii, ee);
	if (flag1) {
		cout << "插入数据后的数组为：" << endl;
		DispList(Link);
	}
	else cout << "插入位置不正确" << endl;
	cout << "如果要插入一个数进入链表中，请输入任意非零数进入插入，否则跳过该次插入请输入0:";
	cin >> flag;
}
cout << "如果要删除链表一个数据，请输入任意非零数进入删除，否则跳过该次删除请输入0:";
cin >> flag;
while (flag) {
	cin.clear();
	int  eee,iii;
	cout<<"请输入要删除的数据的值：" << endl;
	cin>>eee;
	LocateElem(Link, iii, eee);
	bool flag2= ListDelete(Link,iii, eee);
	if (flag2) {
		cout << "删除成功！" << endl;
		cout << "删除该数据后的数组显示如下：" << endl;
		DispList(Link);
		cout << endl;
	}
	else cout << "要删除的数据并不在数组内"<<endl;
	cout << "如果要删除链表一个数据，请输入任意非零数进入删除，否则跳过该次删除请输入0:" << endl;
	cin >> flag;
}
Rollback(Link);
cout<<"翻转后的链表内容为：" << endl;
DispList(Link);
system("pause");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

}

List.h
#include <stdio.h>
#include “time.h”
#include “math.h”
#include “stdlib.h”

typedef struct LNode
{
int data;
struct LNode *next;
}LinkNode;
void InitList(LinkNode *&L);
void CreateListF(LinkNode *&L, int a[], int n);
void DispList(LinkNode *L);
int LocateElem(LinkNode *L, int & i, int e);
bool ListInsert(LinkNode *&L, int i, int e);
bool ListDelete(LinkNode *&L, int i, int &e);
void Rollback(LinkNode *&L);

List.cpp
#include"pch.h"
#include “header.h”
void InitList(LinkNode *&L)
{
L = (LinkNode *)malloc(sizeof(LinkNode));
L->next = NULL;
}
void CreateListF(LinkNode *& L, int a[], int n)
{
LinkNode * s;
L = (LinkNode *)malloc(sizeof(LinkNode));
L->next = NULL;
for (int i = 0; i < n; i++)
{
s = (LinkNode *)malloc(sizeof(LinkNode));
s->data = a[i];
s->next = L->next;
L->next = s;
}
}
void DispList(LinkNode *L)
{
LinkNode *p = L->next;
while (p != NULL)
{
printf("%d", p->data);
printf("\n");
p = p->next;
}
printf("\n");
}
int LocateElem(LinkNode *L, int & i, int e)
{
i = 1;
LinkNode *p = L->next;
while (p != NULL && p->data != e)
{
p = p->next;
i++;
}
if (p == NULL)
return(0);
else
return(i);

}

bool ListInsert(LinkNode *& L, int i, int e)
{
/if (i < 1 || i>10)
{
return false;
}/
int j = 0;
LinkNode *p = L, *s;
if (i <= 0) return false;
while (j < i - 1 && p != NULL)
{
j++;
p = p->next;
}
if (p == NULL)
return false;
else
{
s = (LinkNode *)malloc(sizeof(LinkNode));
s->data = e;
s->next = p->next;
p->next = s;
return true;
}
}

bool ListDelete(LinkNode *& L,int i,int & e)
{
int j = 0;
LinkNode *p = L, *q;
while (p != NULL &&j<i-1)
{
j++;
p = p->next;
}
if (pNULL)
{
return false;
}
else
{
q = p->next;
if (qNULL)
{
return false;
}
e = q->data;
p->next = q->next;
free(q);
return true;
}
}

void Rollback(LinkNode &L)
{
LinkNode pre = NULL;
LinkNode* pNext = NULL;
LinkNode* pCur = L->next;
while (pCur)
{
pNext = pCur->next;
pCur->next = pre;
pre = pCur;
pCur = pNext;
}
L->next = pre;
}

2、栈的链式存储结构实现
（1）用随机函数生成10个3位整数（100~999），把这些整数应用入栈操作存于堆栈中，在入栈接口处设置断点①，按“F5”启动调试，按“F10”逐句执行，直到数据全部入栈。程序暂停时观察栈顶数据和栈顶位置；
（2）应用出栈操作输出堆栈的内容，在出栈接口处设置断点②，按“F5”启动调试，按“F10”逐句执行，直到所有数据完全出栈，程序暂停时观察栈顶数据和栈顶位置的变化；

所采取的方案：
4. 链式线性表带表头，非循环结构；
5. 链表内容为无序；
6. 链表内容（结点数值）可以重复，也可以不重复

Stackmain.cpp
#include “pch.h”
#include
#include"header.h"

int main()
{
LinkStNode *Stack;
InitStack(Stack);
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
for (int i = 0; i < 10; i++)
{
int a = rand()%900+100;
Push(Stack, a);
}
for (int i = 0; i < 10; i++)
{
int aa;
Pop(Stack,aa);
printf("%d", aa);
printf("\n");
}
system(“pause”);
}

Stack.h
#include “malloc.h”
#include"time.h"
typedef struct linknode
{
int data;
struct linknode * next;
}LinkStNode;
void InitStack(LinkStNode *&s);
void DestroyStack(LinkStNode *&s);
bool StackEmpty(LinkStNode *s);
void Push(LinkStNode *&s, int e);
bool Pop(LinkStNode *&s, int &e);
bool GetTop(LinkStNode *s, int &e);

stack.cpp
#include"pch.h"
#include “header.h”
void InitStack(LinkStNode *& s)
{
s = (LinkStNode *)malloc(sizeof(LinkStNode));
s->next = NULL;
};

void DestroyStack(LinkStNode *& s)
{
LinkStNode *pre=s,*p = s->next;
while (p != NULL)
{
free(pre);
pre = p;
p = p->next;
}
free(pre); //s指向尾结点,释放其空间
};

bool StackEmpty(LinkStNode * s)
{
return(s->next == NULL);
};

void Push(LinkStNode *& s, int e)
{
LinkStNode *p;
p = (LinkStNode *)malloc(sizeof(LinkStNode));
p->data = e; //新建元素e对应的结点p
p->next = s->next; //插入p结点作为开始结点
s->next = p;
};

bool Pop(LinkStNode *& s, int & e)
{
LinkStNode *p;
if (s->next == NULL) //栈空的情况
return false;
p = s->next; //p指向开始结点
e = p->data;
s->next = p->next; //删除p结点
free§; //释放p结点
return true;
};

bool GetTop(LinkStNode * s, int & e)
{
LinkStNode *p;
if (s->next == NULL) //栈空的情况
return false;
p = s->next; //p指向开始结点
e = p->data;
s->next = p->next; //删除p结点
free§; //释放p结点
return true;
};
3、队列的链式存储结构的实现
（1）用随机函数生成10个3位整数（100~999），把这些整数应用入队操作存于队列中；
（2）应用遍历操作输出队列的内容；
（3）把队列的内容翻转，应用出队操作输出队列的内容。

Queuemain.cpp
#include “pch.h”
#include
#include"header.h"
#include"time.h"

int main()
{
LinkQuNode *QuNode;
InitQueue(QuNode);
time_t t; // 定义时间变量
srand((unsigned)time(&t)); //由时间确定随机序列，执行一次
for (int i = 0; i < 10; i++)
{
int a = rand() % 900 + 100;
enQueue(QuNode, a);
}
printfo(QuNode->front);//应用遍历操作输出队列的内容；
printf("\n");
printf("\n");
printf("\n");
printf("\n");
QuNode->rear = QuNode->front;//在把队列的内容翻转前，把链队头结点的队尾结点改变
Rollback(QuNode->front);//把队列的内容翻转，并且QuNode->front自动指向数据结尾位置（不知道为什么）
for (int i = 0; i < 10; i++)
{
int r;
deQueue(QuNode, r);//把队列的内容翻转后，应用出队操作输出队列的内容
printf("%d", r);
printf("\n");
printf("\n");
}

system("pause");
1

}

Queue.h
#pragma once
#include"pch.h"
#include “malloc.h”
#include
typedef struct qnode
{
int data;
struct qnode * next;
}DataNode;
typedef struct qlink
{
DataNode * front;
DataNode * rear;
}LinkQuNode;
void InitQueue(LinkQuNode *&q);
void DestoryQueue(LinkQuNode *&q);
bool QueueEmpty(LinkQuNode *&q);
void enQueue(LinkQuNode *&q, int e);
bool deQueue(LinkQuNode *&q, int &e);
void printfo(DataNode *p);
DataNode * Rollback(DataNode *&L);
Queue.cpp
#include"pch.h"
#include “header.h”

void InitQueue(LinkQuNode *& q)
{
q = (LinkQuNode *)malloc(sizeof(LinkQuNode));
q->front = q->rear = NULL;
}

void DestoryQueue(LinkQuNode *& q)
{
DataNode *pre = q->front, *p;
if (pre!=NULL)
{
p = pre->next;
while (p != NULL)
{
free(pre);
pre = p; p = p->next;
}
free(q);
}
}

bool QueueEmpty(LinkQuNode *& q)
{
return (q->rear==NULL);
}

void enQueue(LinkQuNode *& q, int e)
{
DataNode *p;
p = (DataNode *)malloc(sizeof(DataNode));
p->data = e;
p->next = NULL;
if (q->rear == NULL)
q->front = q->rear = p;
else
{
q->rear->next = p;
q->rear = p;
}
}

bool deQueue(LinkQuNode *& q, int & e)
{
DataNode *t;
if (q->rear == NULL) //队列为空
return false;
t = q->front; //t指向第一个数据结点
if (q->front == q->rear) //队列中只有一个结点时
q->front = q->rear = NULL;
else //队列中有多个结点时
q->front = q->front->next;
e = t->data;
free(t);
return true;
}

void printfo(DataNode * p)
{
while § {
int aa = p->data;
printf("%d", aa);
p = p->next;
printf("\n");
}
}

DataNode * Rollback(DataNode & L)
{
//ActList temp=new ActList;
if (L == NULL || L->next == NULL) return L; //少于两个节点没有反转的必要。
DataNode * p;
DataNode * q;
DataNode * r;
p = L;
q = L->next;
L->next = NULL; //旧的头指针是新的尾指针，next需要指向NULL
while (q) {
r = q->next; //先保留下一个step要处理的指针
q->next = p; //然后p q交替工作进行反向
p = q;
q = r;
}
L = p; // 最后q必然指向NULL，所以返回了p作为新的头指针
return L;
}

4、栈和队列的简单应用：
编写函数，判断给定的字符串是否回文。（可以设计多种不同算法实现）
回文数main.cpp
#include “pch.h”
#include"header.h"
#include
bool symmetry(ElemType str[])
{
int i; ElemType e;
SqStack *st;
InitStack(st); //初始化栈
for (i = 0; str[i] != ‘\0’; i++) //将串所有元素进栈
Push(st, str[i]); //元素进栈
for (i = 0; str[i] != ‘\0’; i++)
{
Pop(st, e); //退栈元素e
if (str[i] != e) //若e与当前串元素不同则不是对称串
{
DestroyStack(st); //销毁栈
return false;
}
}
DestroyStack(st); //销毁栈
return true;
}

int main()
{
ElemType str[] = “12343fd21”;
if (symmetry(str))
printf("%s是回文串\n", str);
else
printf("%s不是回文串\n", str);
return 1;
}

回文数.h
#pragma once
//顺序栈基本运算算法
#include <stdio.h>
#include <malloc.h>
#define MaxSize 100
typedef char ElemType;
typedef struct
{
ElemType data[MaxSize];
int top; //栈指针
} SqStack; //顺序栈类型
void InitStack(SqStack *&s);
void DestroyStack(SqStack *&s);
bool StackEmpty(SqStack *s);
bool Push(SqStack *&s, ElemType e);
bool Pop(SqStack *&s, ElemType &e);
bool GetTop(SqStack *s, ElemType &e);
回文数.cpp
#include"pch.h"
#include"header.h"
void InitStack(SqStack *&s)
{
s = (SqStack *)malloc(sizeof(SqStack));
s->top = -1;
}
void DestroyStack(SqStack *&s)
{
free(s);
}
bool StackEmpty(SqStack *s)
{
return(s->top == -1);
}
bool Push(SqStack *&s, ElemType e)
{
if (s->top == MaxSize - 1) //栈满的情况，即栈上溢出
return false;
s->top++;
s->data[s->top] = e;
return true;
}
bool Pop(SqStack *&s, ElemType &e)
{
if (s->top == -1) //栈为空的情况，即栈下溢出
return false;
e = s->data[s->top];
s->top–;
return true;
}
bool GetTop(SqStack *s, ElemType &e)
{
if (s->top == -1) //栈为空的情况，即栈下溢出
return false;
e = s->data[s->top];
return true;
}

五、实验结果及分析
1、线性表的链表实现：

数据插入成功后，输入任意非零数进入查询数据，输入0进入另一个操作。以下情况依此类推

2、栈的链式存储结构实现
进栈

出栈

3、队列的链式存储结构的实现

4、栈和队列的简单应用：