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

广州大学学生实验报告

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

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

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

所采取的方案：

链式线性表带表头，非循环结构；
链表内容为无序；
链表内容（结点数值）可以重复，也可以不重复
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");

}

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");

}

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、栈和队列的简单应用：

实验一链式存储结构的基本操作相关推荐

3.3 栈的链式存储结构
<?php header("content-type:text/html;charset=utf-8"); /*** 栈的链式存储结构的基本操作**包括* 1.初始化 __c ...
【数据结构】实验报告10 顺序、链式存储结构的二叉树递归遍历、层次遍历求高度
一.实验目的和要求 (源码在最后) 要求: 两种及以上存储结构(建议顺序存储结构和链式存储结构各一).两种及以上方法(建议递归遍历和层次遍历方法各一).分析各代码性能. 抽象数据类型(二叉树)独立 ...
线性表的顺序、链式存储结构基本操作
线性表的抽象数据类型 operation InitList(&L):初始化操作,建立一个空的线性表L ListEmpty(L):若线性表为空,返回true,否则返回false ClearLis ...
数据结构（二）:线性表包括顺序存储结构（顺序表、顺序队列和顺序栈）和链式存储结构（链表、链队列和链栈）...
还记得数据结构这个经典的分类图吧: 今天主要关注一下线性表. 什么是线性表线性表的划分是从数据的逻辑结构上进行的.线性指的是在数据的逻辑结构上是线性的.即在数据元素的非空有限集中 (1) 存在唯一的 ...
队列的链式存储结构及实现
队列的链式存储结构,其实就是线性表的单链表,只不过它只是尾进头出而已,我们把它简称为链队列.为了操作上的方便,我们将队头指针指向链队列的头结点,而队尾指针指向终端节点.如果空队列时,front和re ...
串--串的定义，顺序、链式存储结构，BF、KMP模式匹配算法（C语言描述）
此文章仅作为自己学习过程中的记录和总结,同时会有意地去用英文来做笔记,一些术语的英译不太准确,内容如有错漏也请多指教,谢谢! 一.串(String)的定义: 串(String):由零个或多个字符组成的 ...
线性表-链式存储结构
3.6 线性表的链式存储结构 3.6.1 顺序存储结构不足的解决办法前面我们讲的线性表的顺序存储结构.它是有缺点的,最大的缺点就是插入和删除时需要移动大量元素,这显然就需要耗费时间.能不能想办法解决 ...
数据结构之线性表——（二、链式存储结构）[c语言]
数据结构之线性表--(二.链式存储结构-单链表) 链式存储结构以及基本运算的实现背景:由于线性表的存储特点是用物理上的相邻实现逻辑上的相邻,他要求用连续的存储单元顺序存储线性表中的各个元素,所以,对 ...
线性表（链式存储结构）
前言线性表(顺序存储结构-用数组描述) 为了解决顺序存储不足:用线性表另外一种结构-链式存储.在顺序存储结构(数组描述)中,元素的地址是由数学公式决定的,而在链式储存结构中,元素的地址是随机分布的, ...

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

实验一链式存储结构的基本操作相关推荐

最新文章

热门文章

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

实验一 链式存储结构的基本操作相关推荐

最新文章

热门文章

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

实验一链式存储结构的基本操作相关推荐