实验8.2 队列类的定义与实现

最新推荐文章于 2022-09-04 17:42:03 发布
最新推荐文章于 2022-09-04 17:42:03 发布
阅读量2k 收藏 14
点赞数 6
分类专栏： # C++入门/实验课作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45884316/article/details/106752524
版权

题目

编写程序queue.h，用链表实现队列（或栈）类。在测试程序lab9_2.cpp中定义一个整型队列（或栈）对象，插入5个整数，压入队列（或栈），再依次取出并显示出来。

C++代码如下：

//node.h

#ifndef NODE_H//结点类模板
#define NODE_H
template<class T>
class linkedlist;//新添
template<class T>//新添
class node
{
private:
	node<T>* next;//指向后继指针的结点
public:
	T data;//数据域
	node(const T& data, node<T>* next = 0);//构造函数
	void insertAfter(node<T>* p);//在本结点之后插入一个同类的结点P
	node<T>* deleteAfter();//删除本结点的后继结点，并返回其地址
	node<T>* nextNode();//获取后继结点的地址
	const node<T>* nextNode()const;//获取后继结点的地址
	friend linkedlist<T>;//因操作需要将linkedlist<T>作为node的友元（新添）
};
template<class T>
node<T>::node(const T& data, node<T>* next/*=0*/) :data(data), next(next)
{
}
template<class T>
node<T>* node<T>::nextNode()
{
	return next;
}
template<class T>
const node<T>* node<T>::nextNode()const
{
	return next;
}
template<class T>
void node<T>::insertAfter(node<T>* p)
{
	p->next = next;
	next = p;
}
template<class T>
node<T>* node<T>::deleteAfter()
{
	node<T>* tempPtr = next;
	if (next == 0)return 0;
	next = tempPtr->next;
	return tempPtr;
}
#endif

//link.h

#ifndef LINKEDLIST_H
#define LINKEDLIST_H
#include<iostream>
using namespace std;
#include "node.h"
template<class T>
class linkedlist
{
private:
	node<T>* front, * rear;//表头和表尾指针
	node<T>* prevPtr, * currPtr;//记录表当前遍历位置的指针，由插入和删除操作更新
	int size;//表中的元素个数
	int position;//当前元素在表中的位置序号，由函数reset使用
	//函数成员：
	//生成新结点，数据域为item,指针域为ptrNext
	node<T>* nextNode(const T& item, node<T>* ptrNext = NULL);
	void freeNode(node<T>* p);//释放结点                                     (未用)
	//将链表L复制到当前表（假设当前表为空）
	//被复制构造函数和“operator=”调用
	void copy(linkedlist<T>& L);//（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
public:
	void print();//打印链表类里的数据及其数目（新添）
	linkedlist();
	linkedlist(linkedlist<T>& L);//复制构造函数（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
	~linkedlist();
	linkedlist<T>& operator=(linkedlist<T>& L);//重载赋值运算符（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
	int getSize()const;//返回链表中的元素个数
	bool isEmpty()const;//链表是否为空                                      (未用)
	void reset(int pos = 0);//初始化游标的位置（第一位数的位置设为0)
	void next();//使游标移动到下一个结点
	bool endOfList()const;//游标是否到了链尾
	int currentPosition(void);//返回游标当前的位置
	void insertFront(const T& item);//在表头插入结点
	void insertRear(const T& item);//在表尾添加结点
	void insertAt(const T& item);//在当前结点之前插入结点
	void insertAfter(const T& item);//在当前结点之后插入结点
	T deleteFront();//删除头结点
	void deleteCurrent();//删除当前结点
	T& data();//返回对当前结点成员数据的引用
	const T& data()const;//返回对当前结点成员数据的常引用
	//清空链表：释放所有结点的内存空间。被析构函数和“operator ="调用
	void clear();
};
template<class T>
node<T>* linkedlist<T>::nextNode(const T& item, node<T>* ptrNext)//生成新结点，数据域为item,指针域为ptrNext
{

	node<T>* tempPtr = new node<T>(item, ptrNext);
	return tempPtr;
}
template<class T>
void linkedlist<T>::freeNode(node<T>* p)//释放结点
{
	delete p;
}
template<class T>
void linkedlist<T>::print()//打印链表类里的数据及其数目（新添）
{
	reset();
	while (!endOfList())
	{
		cout << data() << " ";
		next();
	}
	cout << endl;
	cout << "size=" << getSize() << endl;
}
template<class T>
linkedlist<T>::linkedlist()//构造函数
{
	size = 0;
	front = rear = new node<T>(0);
	currPtr = prevPtr = front;
}
template<class T>
int linkedlist<T>::currentPosition(void)//返回游标当前的位置
{
	node<T>* tempPtr = front->nextNode();
	position = 0;
	while (tempPtr != currPtr)
	{
		tempPtr = tempPtr->nextNode();
		position++;
	}
	return position;
}

template<class T>
int linkedlist<T>::getSize()const//返回链表中的元素个数
{
	return size;
}


template<class T>
T& linkedlist<T>::data()//返回对当前结点成员数据的引用
{
	return currPtr->data;
}
template<class T>
const T& linkedlist<T>::data()const//返回对当前结点成员数据的常引用
{
	return currPtr->data;
}
template<class T>
void linkedlist<T>::next()//使游标移动到下一个结点
{
	prevPtr = currPtr;
	currPtr = currPtr->nextNode();
}
template<class T>
bool linkedlist<T>::endOfList()const//游标是否到了链尾
{
	if (currPtr == NULL)return true;
	else return false;
}
template<class T>
bool linkedlist<T>::isEmpty()const//链表是否为空  
{
	if (front == rear)return true;
	else return false;
}
template<class T>
void linkedlist<T>::reset(int pos)//初始化游标的位置（第一位数的位置设为0)
{
	prevPtr = front;
	currPtr = front->nextNode();
	position = pos;
	for (int i = 0; i < position; i++)
	{
		prevPtr = currPtr;
		currPtr = currPtr->nextNode();
	}
}
template<class T>
void linkedlist<T>::insertFront(const T& item)//在表头插入结点
{
	prevPtr = currPtr;
	currPtr = nextNode(item, front->nextNode());
	front->next = currPtr;
	if (rear == front)
	{
		rear = currPtr;
	}
	size++;
}
template<class T>
void linkedlist<T>::insertRear(const T& item)//在表尾添加结点
{
	prevPtr = currPtr;
	currPtr = nextNode(item, rear->nextNode());
	rear->next = currPtr;
	rear = currPtr;
	size++;
}
template<class T>
void linkedlist<T>::insertAfter(const T& item)//在当前结点之后插入结点
{
	prevPtr = currPtr;
	node<T>* tempPtr = nextNode(item, currPtr->nextNode());
	currPtr->next = tempPtr;
	if (currPtr == rear)
	{
		rear = tempPtr;
	}
	currPtr = tempPtr;
	size++;

}
template<class T>
void linkedlist<T>::insertAt(const T& item)//在当前结点之前插入结点
{
	currPtr = nextNode(item, prevPtr->nextNode());
	prevPtr->next = currPtr;
	size++;
}
template<class T>
T linkedlist<T>::deleteFront()//删除头结点
{
	currPtr = front->nextNode();
	delete front;
	front = currPtr;
	size--;
	return front->data;
}
template<class T>
void linkedlist<T>::deleteCurrent()//删除当前结点
{
	node<T>* tempPtr = currPtr;
	prevPtr->deleteAfter();
	delete currPtr;
	currPtr = prevPtr;
	size--;
}
template<class T>
void linkedlist<T>::clear()//清空链表：释放所有结点的内存空间。被析构函数和“operator ="调用
{
	node<T>* tempPtr = front->nextNode();
	while (tempPtr != NULL)
	{
		node<T>* tempQ = tempPtr;
		tempPtr = tempPtr->nextNode();
		delete tempQ;
		size--;
	}
	rear = front;
	currPtr = prevPtr = front;
}
template<class T>
linkedlist<T>::~linkedlist()//析构函数
{
	clear();
	delete front;
}
template<class T>
void linkedlist<T>::copy(linkedlist<T>& L)//将链表L复制到当前表（假设当前表为空）被复制构造函数和“operator=”调用
//（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
{
	//clear();
	L.reset();
	for (int i = 0; i < L.size; i++)
	{
		insertRear(L.data());
		L.next();
	}

}
template<class T>
linkedlist<T>& linkedlist<T>::operator =(linkedlist<T>& L)//重载赋值运算符（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
{
	clear();
	front->next = NULL;
	copy(L);
	cout << "调用重载运算符=" << endl;
	return *this;
}
template<class T>
linkedlist<T>::linkedlist(linkedlist<T>& L)//复制构造函数（因实现需要，无法使用(linkedlist<T>const&L)作为形参表）
{
	size = 0;
	front = rear = new node<T>(0);
	currPtr = prevPtr = front;
	copy(L);
	cout << "调用复制构造函数" << endl;
}
#endif

//queue.h

//queue.h 
#ifndef QUEUE_CLASS 
#define QUEUE_CLASS 
#include <iostream> 
#include <cstdlib> 
using namespace std; 
#include "link.h" 
template <class T> 
class Queue { 
private: LinkedList<T> queueList; 
public: 
	Queue(void); 
	void QInsert(const T& elt); 
	T QDelete(void); 
	T QFront(void); 
	int QLength(void) const; 
	int QEmpty(void) const; 
	void QClear(void);
}; 
template <class T> 
Queue<T>::Queue(void) 
{} 
template <class T> 
int Queue<T>::QLength(void) const 
{ 
	return queueList.ListSize(); 
} 
template <class T> 
int Queue<T>::QEmpty(void) const 
{ 
	return queueList.ListEmpty();
} 
template <class T> 
void Queue<T>::QClear(void) 
{ 
	queueList.ClearList(); 
} 
template <class T> 
void Queue<T>::QInsert(const T & elt) 
{ 
	queueList.InsertRear(elt);
} 
template <class T> T Queue<T>::QDelete(void) 
{ 
	if (queueList.ListEmpty()) 
	{ 
		cerr << "Calling QDelete for an empty queue!" << endl;
		exit(1); 
	} 
	return queueList.DeleteFront(); 
} 
template <class T> T Queue<T>::QFront(void) 
{ 
	if (queueList.ListEmpty()) 
	{ 
		cerr << "Calling QFront for an empty queue!" << endl; 
		exit(1); 
	} 
	queueList.Reset();
	return queueList.Data(); 
} 
#endif // QUEUE_CLASS

//lab9_2.cpp

//lab9_2.cpp 
#include "queue.h" 
int main() 
{ 
	Queue<int> A; 
	for(int i=0;i<5;i++) 
	{ 
		A.QInsert(i); 
	} 
	cout << " 队列 A 的元素为： "; 
	while (!A.QEmpty()) 
	{ 
		cout << A.QFront() << " ";
		A.QDelete(); 
	} 
	cout << endl;
}
<Running Snail>
关注
专栏目录
【LangChain编程：从入门到实践】设计并实现一个多模态代理
程序员光剑
07-07 822
随着人工智能技术的不断发展，特别是大模型的兴起，构建能够理解和利用多种类型输入信息（如文本、图像、语音等）的人工智能系统成为了一个重要且具有挑战性的课题。多模态代理正是为了适应这一需求而诞生的，它们旨在集成不同模态的信息，进行综合分析与决策。多模态代理是能够整合并处理来自不同来源、不同形式的数据（如文本、音频、视频、图像等），并以协同方式执行任务的智能实体。这些代理通常具备强大的自然语言处理、图像识别、语音理解等能力，并能根据不同的输入模态灵活调整策略。深度学习框架。
一切皆是映射：DQN的多智能体扩展与合作竞争环境下的学习
最新发布
程序员光剑
09-17 1240
在过去的几十年里，强化学习因其在解决复杂决策问题上的潜力而受到广泛关注。DQN，作为一种基于深度学习的强化学习算法，不仅成功地解决了许多单一智能体的控制问题，还为多智能体系统的智能决策开辟了新途径。然而，单一智能体的行动往往受限于个体利益最大化，而多智能体系统中，智能体间的合作与竞争关系为了解决更复杂的问题提供了机会。DQN是一种结合深度学习与Q-learning的算法，通过神经网络来近似Q函数，从而学习最优的行动策略。
利用链表实现队列
weixin_43824601的博客
11-14 681
队列是一种只允许在表的前端进行删除操作，而在表的后端进行插入操作的线性数据结构 我们可以利用链表来实现队列，具体实现代码如下： import java.util.NoSuchElementException; /** * 用链表实现队列 * @author Victor Gong * * @param <Item> 队列中元素类型 */ public class LinkedQueue<Item> { private Node first; //头结点 priva
队列的定义以及实现
Sun.ME的博客
03-05 2675
队列是只允许在一端进行插入操作，而在另外一端进行删除操作的线性表。 队列是一种先进先出的线性表，简称FIFO，允许插入的一端称之为队尾，允许删除的一端称之为队头。 线性表有顺序存储和链式存储，栈是线性表，队列作为一种特殊的线性表，也同样存在顺序存储结构和链式存储结构。 入队：在队列的末尾追加一个元素，不需要移动任何元素，其时间复杂度为O(1); 出队：队列元素的出列是在队头，即下标为0的位...
数据结构----------链表Linked List 用链表实现队列，栈
一李
09-05 314
动态数据结构-----引用（指针）------递归机制 Linked List 数据存储在“节点（Node）”中 链表存储的数据是有限的，最后一个节点是null 优点：真正的动态，不需要处理固定容量的问题 缺点：没有了随机访问的能力 为链表设立虚拟头结点。dummyHead(虚拟头结点 ) 链表的遍历查询修改，删除元素。 不论是添加还是删除操作，都是需要找到删除得索引，然后把...
链表实现队列
acm_JL的博客
03-21 442
/***********************************************************/ // 程序名称：StackOfLink.cpp // 程序目的：设计一个链表实现的队列的程序 /***********************************************************/ #include #include #define
C++数据结构--队列（链表实现）
海到无边天作岸 山登绝顶我为峰
04-07 1564
测试代码 #include<iostream> using namespace std; template<class datatype> struct node{ datatype data; node<datatype> *next; }; template<class datatype> class queue{ public: que...
数据结构实验2：C++实现单链表类
u25th_engineer的博客
11-10 1953
太简单了，没啥可说的，代码意义明白如话。 题目与要求： 实验2 2.1 实验目的 熟练掌握线性表的链式存储结构。 熟练掌握单链表的有关算法设计。 根据具体问题的需要，设计出...
操作系统实验一CPU调度
08-02
总结来说，"操作系统实验一CPU调度"是一个结合理论与实践的绝佳学习机会，它要求我们设计并实现一个基于优先权的调度算法，利用NetBeans IDE 8.2进行编程，以模拟和分析CPU资源的分配。这个过程将帮助我们深入理解...
java 链表指针_java链表应用--基于链表实现队列详解（尾指针操作）
weixin_32612347的博客
02-12 228
本文实例讲述了java基于链表实现队列。分享给大家供大家参考，具体如下：在开始栈的实现之前，我们再来看看关于链表的只在头部进行的增加、删除、查找操作，时间复杂度均为O(1)。一、链表改进分析对于队列这种数据结构，需要在线性结构的一端插入元素，另外一端删除元素。因此此时基于链表来实现队列，则有一端的时间复杂度为O(n)。因此我们不能使用之前已经实现的链表结构，我们需要改进我们的链表。思路如下：1.参...
CPPexam9.zip_数据结构_Visual_C++_
08-11
1. 编写程序 Node.h 实现例 9-5 的节点类，并编写测试程序 lab9_1.cpp 实现链表的基本操作。2. 编写程序 link.h 实现例 9-6 的链表类。在测试程序 lab9_2.cpp 中声明两个整型链表 A和 B，分别插入 5 个元素，然后把 B 中的元素加入 A 的尾部。3. 编写程序 queue.h，用链表实现队列（或栈）类。在测试程序 lab9_3.cpp 中声明一个 整型队列（或栈）对象，插入 5 个整数，压入队列（或栈），再依次取出并显示出来。
数据结构学习（五） Java链表实现队列
weixin_30851409的博客
06-12 83
package queue; /** * @Title: LinkedListQueue * @ProjectName demo */ public class LinkedListQueue<E> implements Queue<E> { private class Node { private Node next...
C语言：链表实现队列（queue）
weixin_50711484的博客
09-04 958
先到先得，后到后得是队列得核心思想。文章也是这样，先看此文章的人当然先学会啦！
链表(LinkedList) C 语言实现
热门推荐
song_hui_xiang
07-24 1万+
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。如图： 下面是代码实现： #include #include struct student { int score; struct student *next; }; typedef struct student NODE; //typedef为C语言的关
C语言 队列的实现（链表实现）
ruanze_bupt的博客
08-24 601
【代码】C语言 队列的实现（链表实现）
利用链表简单实现队列（Queue）
发光吖的博客
08-08 399
package com.briup.day13.que5; public class Queue { private Node first;//头节点 private Node last;//尾节点 private int size = 0;//有效元素的个数 //将指定元素插入到此队列中 public void add(int element) { //获取尾节点对象，保存原来的尾节点到一个变量中，待会得用 Node lNode = last; //把当前数据包装成一个新的node
LinkedList实现原理
qq_43484972的博客
04-17 368
@LinkedList实现原理 流程分析：程序从main函数开始执行，首先执行LinkedList linkedList = new LinkedList();即实例化LinkedList对象(在堆空间中开辟一个空间，对象包括三个成员变量：size结点个数初始值0,first首结点初始值null，last尾结点初始值null)，栈中的linkedList为对象引用指向堆中0x1101对象。然后执...
面向对象程序设计C++——利用链表实现栈和队列（继承）
ChristensonLee的博客
05-08 1748
**【问题描述】**利用链表实现栈和队列 队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。下面是队列的示意图： 栈具有后进先出的特点。所有入栈的元素都放在栈顶，出栈时栈顶元素先出。下面是栈的示意图： 这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。本实验要求以上一个实验实现的链表类作为基类并设计它的两个派生类。 要求： (1) 在上一个实验实现的链表
8.C++ Queue队列类模版实现
抵抗时间扭曲，坚持做一件有意义的事
02-25 1684
1.队列的介绍 队列的定义 队列（Queue）是一种线性存储结构。它有以下几个特点： 按照"先进先出（FIFO, First-In-First-Out）"方式进出队列。 队列只允许在"队首"进行取出操作(出队列)，在"队尾"进行插入操作(入队列) 队列实现的方式有两种 基于动态数组实现 基于链表形式实现 队列需要实现的函数 T dequeue() : 出队列,并返回取出的元素 void enqueue(const T &t) : 入队列 T &head() : 获取.
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值