广州大学《数据结构》实验一：线性表、栈与队列

于 2024-07-27 19:00:27 发布
阅读量534 收藏 13
点赞数 9
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73442756/article/details/140687752
版权

一、实验基本知识

        本实验所涉及的数据结构有：单链表、栈与队列，若对以上数据结构的原理不熟悉，或者不知道如何从零实现以上数据结构的，可以点击以下链接查看：

《数据结构》学习笔记01：线性表

《数据结构》学习笔记02：栈与队列

二、实验内容

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。

三、实验源代码

1、线性表的链表实现

/* 01-链表 */

//链表结点
typedef struct LNode
{
	int data;
	struct LNode* next;
}LNode, * List;

//链表初始化
void InitList(List& L)
{
	L = new LNode;		//带有头结点
	L->next = NULL;
	L->data = 0;			//以头结点的数据域存放链表的长度
}

//链表的插入
void Insert(List& L, int i, int e)
{
	LNode* p = L;
	int j = 0;
	while (p && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!p || j > i - 1)
		return;
	LNode* s = new LNode;
	s->data = e;
	s->next = p->next;
	p->next = s;
	++(L->data);
}

//链表的删除
void Delete(List& L, int i, int& e)
{
	LNode* p = L;
	int j = 0;
	while (p->next && j < i - 1)
	{
		p = p->next;
		j++;
	}
	if (!(p->next) || j > i - 1)
		return;
	e = p->next->data;
	p->next = p->next->next;
	--(L->data);
}

//按值查找
int Search(List& L, int e)
{
	LNode* p = L->next;
	int i = 1;
	while (p)
	{
		if (p->data == e)
			return i;
		p = p->next;
		i++;
	}
	return 0;
}

//按值删除元素
void Remove(List& L, int e)
{
	if (!Search(L, e))
		return;
	else
		Delete(L, Search(L, e), e);
}

//遍历链表
void Traverse(List& L)
{
	LNode* p = L->next;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

//判链表是否为空
bool Empty(List& L)
{
	return L->data == 0;
}

//求链表长度
int Length(List& L)
{
	return L->data;
}

//逆转链表
void Rotate(List& L)
{
	if (Empty(L))
		return;
	int n = Length(L), e;
	for (int i = 0; i < n - 1; i++)
	{
		Delete(L, n, e);
		Insert(L, i + 1, e);
	}
}

void ListTest1()
{
	srand(int(time(0)));
	int arr[10] = { 0 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		arr[i] = rand() % 900 + 100;

	List L;
	InitList(L);

	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		Insert(L, i + 1, arr[i]);

	Traverse(L);

	int n, i;

	cout << "查找的元素为：";
	cin >> n;
	cout << "查找的元素位置为：" << Search(L, n) << endl;

	cout << "插入的元素为：";
	cin >> n;
	cout << "插入的位置为：";
	cin >> i;
	Insert(L, i, n);
	cout << "插入元素后的链表为：" << endl;
	Traverse(L);

	cout << "删除的元素为：";
	cin >> n;
	Remove(L, n);
	cout << "删除元素后的链表为：" << endl;
	Traverse(L);

	Rotate(L);
	cout << "翻转后的链表为：" << endl;
	Traverse(L);
}

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

/* 02-栈 */

//链栈结点
typedef struct SNode
{
	int data;
	struct SNode* next;
}SNode, * Stack;

//初始化链栈
void InitStack(Stack& S)
{
	S = NULL;			//不设头结点
}

//入栈
void Push(Stack& S, int e)
{
	SNode* s = new SNode;
	s->data = e;
	s->next = S;
	S = s;
}

//出栈
int Pop(Stack& S)
{
	if (!S)
		return NULL;
	int e = S->data;
	S = S->next;
	return e;
}

//判栈空
bool Empty(Stack& S)
{
	return S == NULL;
}

//遍历栈
void Traverse(Stack& S)
{
	SNode* p = S;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

//取栈顶元素
int GetTop(Stack& S)
{
	if (S)
		return S->data;
	else
		exit(0);
}

void ListTest2()
{
	srand(int(time(0)));
	int arr[10] = { 0 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		arr[i] = rand() % 900 + 100;

	Stack S;
	InitStack(S);

	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		Push(S, arr[i]);

	cout << "初始化栈为：";
	Traverse(S);

	int e;
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		e = Pop(S);
		cout << "出栈元素为：" << e << endl;
		cout << "当前栈顶元素为：" << GetTop(S) << endl;
		cout << "遍历栈：";
		Traverse(S);
	}
}

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

/* 03-队列 */

//链队结点
typedef struct QNode
{
	int data;
	struct QNode* next;
}QNode;

typedef struct
{
	QNode* front;
	QNode* rear;
	int length;
}Queue;

//初始化链队
void InitQueue(Queue& Q)
{
	Q.front = Q.rear = new QNode;
	Q.front->next = NULL;
	Q.length = 0;
}

//入队
void EnQueue(Queue& Q, int e)
{
	QNode* p = new QNode;
	p->data = e;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	Q.length++;
}

//出队
void DeQueue(Queue& Q, int& e)
{
	if (Q.front == Q.rear)
		return;
	QNode* p = Q.front->next;
	e = p->data;
	Q.front->next = p->next;
	if (Q.rear == p)
		Q.rear = Q.front;
	delete p;
	Q.length--;
}

//取队头元素
int GetFront(Queue& Q)
{
	if (Q.front == Q.rear)
		return 0;
	else
		return Q.front->next->data;
}

//取队长
int Length(Queue Q)
{
	return Q.length;
}

//遍历队列
void Traverse(Queue& Q)
{
	QNode* p = new QNode;
	p = Q.front->next;
	if (!p)
		return;
	while (p)
	{
		cout << p->data << " ";
		p = p->next;
	}
	cout << endl;
}

//翻转队列
void Rotate(Queue& Q)
{
	QNode* m = Q.front->next;		//暂存原队列首元素空间
	QNode* move = Q.front->next;
	Q.front->next = Q.rear;			//将首元素替换成末尾元素
	int n = Length(Q);
	for (int i = 0; i < n; i++)
	{
		while (move)
		{
			if (move->next == Q.rear)
			{
				Q.rear->next = move;
				Q.rear = move;
				break;
			}
			move = move->next;
		}
		move = m;
	}
	move->next = NULL;				//最后一个元素的指针域置空
	Q.rear = move;
}

void ListTest3()
{
	srand(int(time(0)));
	int arr[10] = { 0 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		arr[i] = rand() % 900 + 100;

	Queue Q;
	InitQueue(Q);

	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		EnQueue(Q, arr[i]);

	Traverse(Q);

	Rotate(Q);
	cout << "翻转后的队列为：" << endl;
	Traverse(Q);

	int e;
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		DeQueue(Q, e);
		cout << "出队的元素是：" << e << endl;
		Traverse(Q);
	}
}

4、线性表、栈和队列的应用实现

/* 04-线性表的应用 */

//单链表分割
void SpiltList(List head, int pivot, List& smaller, List& greater)
{
	LNode* p = head->next;
	while (p)
	{
		LNode* next = p->next;
		if (p->data < pivot)
		{
			p->next = smaller->next;
			smaller->next = p;
		}
		else
		{
			p->next = greater->next;
			greater->next = p;
		}
		p = next;
	}
}

//括号的匹配
bool Matching()
{
	Stack S;
	InitStack(S);
	bool flag = 1;
	char ch;
	cin >> ch;
	while (ch != '#' && flag)
	{
		switch (ch)
		{
		case '(':
		case '[':
		case '{':
			Push(S, ch);
			break;
		case ')':
			if (!Empty(S) && GetTop(S) == '(')
				Pop(S);
			else
				flag = 0;
			break;
		case ']':
			if (!Empty(S) && GetTop(S) == '[')
				Pop(S);
			else
				flag = 0;
			break;
		case '}':
			if (!Empty(S) && GetTop(S) == '{')
				Pop(S);
			else
				flag = 0;
			break;
		default:
			break;
		}
		cin >> ch;
	}
	if (Empty(S) && flag)
		return true;
	else
		return false;
}

void ListTest4()
{
	srand(int(time(0)));
	int arr[10] = { 0 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		arr[i] = rand() % 900 + 100;

	List head, smaller, greater;
	InitList(head);
	InitList(smaller);
	InitList(greater);

	cout << "-------------单链表分割-------------" << endl;

	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
		Insert(head, i + 1, arr[i]);
	Traverse(head);
	
	int pivot;
	cout << "请输入划分值：";
	cin >> pivot;
	SpiltList(head, pivot, smaller, greater);
	Traverse(smaller);
	Traverse(greater);
	cout << endl;

	cout << "-------------括号匹配-------------" << endl;
	cout << "请输入由各种括号组成的字符串(字符串以\"#\"结尾)：";
	cout << (Matching() == true ? "匹配成功！" : "匹配失败！") << endl;
}

四、实验结果

1、线性表的链表实现

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

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

4、线性表、栈和队列的应用实现

白咩咩001
关注
  • 9
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值