数据结构-队列

最新推荐文章于 2022-07-15 15:15:57 发布

置顶莫影老师

最新推荐文章于 2022-07-15 15:15:57 发布

阅读量745

点赞数

分类专栏：数据结构文章标签： C 模板队列 queue 优先队列

本文链接：https://blog.csdn.net/ydpawx/article/details/77994790

版权

数据结构专栏收录该内容

11 篇文章 2 订阅

订阅专栏

#include <iostream>
#include <string>
using namespace std;
template<class T>
class queue
{
public:
	virtual ~queue() {}
	virtual bool empty() const = 0;
			//判空
	virtual int size() const = 0;
			//长度
	virtual T& front() = 0;
			//表头元素
	virtual T& back() = 0;
			//表位元素
	virtual void pop() = 0;
			//出队
	virtual void push(const T& theElement) = 0;
			//入队
}; 

template<class T>
class arrayQueue : public queue<T>
{
public:
	arrayQueue(int initialCapacity = 10);
	~arrayQueue() { delete[] queue; }
	bool empty() const { return theFront == theBack; }
	int size() const
	{
		return (theBack - theFront + arrayLength) % arrayLength;
	}
	T& front()
	{
		if (theFront == theBack)
		{
			cout << "队列为空" << endl;
			exit(0);
		}
		return queue[(theFront + 1) % arrayLength];
	}
	T& back()
	{
		if (theFront == theBack)
		{
			cout << "队列为空" << endl;
			exit(0);
		}
		return queue[theBack];
	}
	void pop()
	{
		if (theFront == theBack)
		{
			cout << "队列为空" << endl;
		}
		theFront = (theFront + 1) % arrayLength;
		queue[theFront].~T(); 
	}
	void push(const T& theElement);
private:
	int theFront;       
	int theBack;        
	int arrayLength;   
	T *queue;          
};



template<class T>
arrayQueue<T>::arrayQueue(int initialCapacity)
{
	if (initialCapacity < 1)
	{
		exit(0);
	}
	arrayLength = initialCapacity;
	queue = new T[arrayLength];
	theFront = 0;
	theBack = 0;
}

//难点

template<class T>
void arrayQueue<T>::push(const T& theElement)
{
	
	if ((theBack + 1) % arrayLength == theFront)
	{
		T* newQueue = new T[2 * arrayLength];

		
		int start = (theFront + 1) % arrayLength;
		if (start < 2)
			
			copy(queue + start, queue + start + arrayLength - 1, newQueue);
		else
		{ 
			copy(queue + start, queue + arrayLength, newQueue);
			copy(queue, queue + theBack + 1, newQueue + arrayLength - start);
		}

	
		theFront = 2 * arrayLength - 1;
		theBack = arrayLength - 2;  
		arrayLength *= 2;
		queue = newQueue;
	}


	theBack = (theBack + 1) % arrayLength;
	queue[theBack] = theElement;
}

int main(void)
{
	arrayQueue<int> q(4);
	q.push(1);
	cout << "队尾" << q.back() << endl;
	q.push(2);
	cout << "队尾 " << q.back() << endl;
	q.push(3);
	cout << "队尾 " << q.back() << endl;
	q.push(4);
	cout << "队尾" << q.back() << endl;

	cout << "应该是1234,从Front--->Rear" << endl;

	if (q.empty())
		cout << "队列为空" << endl;
	else
		cout << "队列不为空" << endl;

	cout << "队列长度为" << q.size() << endl;

	while (!q.empty())
	{
		cout << "队头元素" << endl;
		cout << "队头 " << q.front() << endl;
		q.pop();
		
	}
		 q.pop(); 
		cout << "最后出队失败 " << endl;

	arrayQueue<int> r(4);
	r.push(1);
	r.push(2);
	r.push(3);
	r.pop();
	r.pop();
	r.push(4);
	r.push(5);
	r.push(6);
	r.push(7);

	cout << "应该是4567,从Front--->Rear" << endl;


	if (r.empty())
		cout << "队为空" << endl;
	else
		cout << "队不为空" << endl;

	cout << "队大小" << r.size() << endl;

	while (!r.empty())
	{
		cout << "队头元素" << endl;
		cout << "队头 " << r.front() << endl;
		r.pop();
	}

	return 0;
}

#include <iostream>
#include <string>
using namespace std;
template <class T>
struct chainNode
{
	T element;
	chainNode<T> *next;
	chainNode(){};
	//结点初始化
	chainNode(const T& element)
	{
		this->element = element;
	}
	//实现队列的FIFO ，尾部插入
	chainNode(const T& element, chainNode<T>* next)
	{
		this->element = element;
		this->next = next;
	}
};
//ADT过程
template <class T>
class queue
{
public:
	virtual ~queue(){};
	virtual bool empty() const = 0;
	virtual int size() const = 0;
	virtual T& front() = 0;
	virtual T& back() = 0;
	virtual void pop() = 0;
	virtual void push(const T& theElement) = 0;
	//在派生类中必须实现
	//一个项目分为多个模块
};
template <class T>
class linkedQueue :public queue<T>
{
public:
	//构造函数+析构函数
	linkedQueue(int initialCapacity = 10)
	{
		//初始化基本数据成员
		queueFront = NULL;
		queueSize = 0;
	}
	~linkedQueue();
	bool empty() const
	{
		return queueSize == 0;
	}
	int size() const
	{
		return queueSize;
	}
	T& front()
	{
		if (queueSize == 0)
		{
			cout << "队为空" << endl;
			exit(0);
		}
		return queueFront->element;
	}
	T& back()
	{
		if (queueSize == 0)
		{
			cout << "队为空" << endl;
			exit(0);
		}
		return queueBack->element;
	}
	void pop();
	void push(const T& theElement);
private:
	chainNode<T>* queueFront;	//指向队头的指针
	chainNode<T>* queueBack;	//指向队尾的队尾
	int queueSize;				//队容量
};
template <class T>
linkedQueue<T>::~linkedQueue()
{
	while (queueFront != NULL)
	{
		//删除头结点  ,保护他下一个结点
		chainNode<T>* nextNode = queueFront->next;
		delete queueFront;
		queueFront = nextNode;
	}
}
template <class T>
void linkedQueue<T>::push(const T& theElement)
{
	//对于基本的数据类型你可以直接new ，自定义类型要用构造函数
	chainNode<T>* newNode = new chainNode<T>(theElement, NULL);
	//队尾增加结点
	//队为空
	if (queueSize == 0)
		queueFront = newNode;
	else
		queueBack->next = newNode;	//队不为空，队尾插入
	queueBack = newNode;
	queueSize++;
}
template <class T>
void linkedQueue<T>::pop()
{
	if (queueFront == NULL)
	{
		cout << "队为空" << endl;
		exit(0);
	}
	chainNode<T>* nextNode = queueFront->next;
	delete queueFront;
	queueFront = nextNode;
	queueSize--;
}
int main()
{
	linkedQueue<string> myQueue;
	myQueue.push("I");
	myQueue.push(" am");
	myQueue.push(" a");
	myQueue.push(" student");
	cout << "Front---->rear:I am a student" << endl;
	if (myQueue.empty())
		cout << "队为空" << endl;
	else
	{
		while (!myQueue.empty())
		{
			cout << myQueue.front();
			myQueue.pop();
		}

		//队空
		cout << "队空后:" << endl;
		myQueue.pop();
	}
	return 0;
}

//priotity.h:

#include <iostream>
#define MaxQueueSize 100		//队列的大小
//数据类型   数据本身  优先权
typedef int ElementType;	//定义数据类型地 别名

//数据 结构体
typedef struct 
{
	int priority;		//优先权---工作量
	ElementType element;//队列中的元素
}DataType;

//队列的结构体
typedef struct
{
	int size;
	//结构体的嵌套
	DataType Queue[MaxQueueSize];
}PriQueue;
//读取文件作业---调度读取
//队列操作
//初始化---初始化基本成员
//size   Queue
void InitQueue(PriQueue *Q)
{
	Q->size = 0;
}
//判断队列是否为空  NULL
//和它的初始化比较
int QueueEmpty(PriQueue *Q)
{
	// -> 指向运算符  C：结构体指针  C++： 类和结构体
	// :: 作用域限定符
	if (Q->size <= 0)
		return 0;   //标志
	else
		return 1;  //不为空
	//  return 0 函数结束
}
//入队 文件操作
int Push(PriQueue *Q, DataType data)
{
	//入队前判断是否满
	if (Q->size >= MaxQueueSize)
	{
		std::cout << "杯子已满，无法再倒水" << std::endl;
		return 0;
	}
	else
	{
		//Q->size=0;
		Q->Queue[Q->size] = data;
		//入队了队列长度就要增长
		Q->size++;
		return 1;
	}

}
//出队
int Pop(PriQueue *Q, DataType *A)
{
	DataType min;		//最小的开始，排序
	int minIndex = 0;
	//短作业优先法
	//喝水，先判断杯子有没有水
	if (Q->size <= 0)
	{
		std::cout << "为空，无法出队" << std::endl;
		return 0;
	}
	else
	{
		//假设第一个作业是最短的
		min = Q->Queue[0];  //1
		for (int i = 1; i < Q->size; i++)
		{
			//多了一个数据项  按照权值排序
			//0
			if (Q->Queue[i].priority < min.priority)
			{
				min = Q->Queue[i];
				minIndex = i;		//出队依据就是最小作业序号
			}
		}
		*A = Q->Queue[minIndex];
		//难点 
		//删除完数组后，后面的元素往前移动
		for (int i = minIndex + 1; i < Q->size; i++)
		{
			Q->Queue[i - 1] = Q->Queue[i];
			minIndex = i;
		}
		Q->size--;
		return 1;
	}



}
//获取队头元素
int GetQueue(PriQueue *Q, DataType *A)
{
	DataType min;		//最小的开始，排序
	int minIndex = 0;
	//短作业优先法
	//喝水，先判断杯子有没有水
	if (Q->size <= 0)
	{
		std::cout << "为空，无法出队" << std::endl;
		return 0;
	}
	else
	{
		//假设第一个作业是最短的
		min = Q->Queue[0];  //1
		for (int i = 1; i < Q->size; i++)
		{
			//多了一个数据项  按照权值排序
			//0
			if (Q->Queue[i].priority < min.priority)
			{
				min = Q->Queue[i];
				minIndex = i;		//出队依据就是最小作业序号
			}
		}
		*A = Q->Queue[minIndex];
		return 1;
	}
}

   // PriotityQueue.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "priotity.h"
#include <stdio.h>

int main()
{

	//文件操作
	PriQueue Q;
	FILE *fp;
	DataType task;
	if ((fp = fopen("task.txt", "r")) == NULL)
	{
		std::cout << "文件夹打开失败" << std::endl;
		exit(0);
	}
	InitQueue(&Q);
	while (!feof(fp))
	{
		fscanf(fp, "%d %d", &task.element, &task.priority);
		Push(&Q, task);	//入队
	}
	int i = 1;	//工作的序号
	std::cout << "\t序号\t任务编号\t优先级" << std::endl;
	while (QueueEmpty(&Q))
	{
		Pop(&Q, &task);
		std::cout << "\t" << i << "\t" << task.element
			<< "\t" << task.priority << std::endl;
		i++;
	}
	system("pause");
	return 0;
}

task.txt文件中内容:

莫影老师

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
数据结构-队列

#include &lt;iostream&gt;#include &lt;string&gt;using namespace std;template&lt;class T&gt;class queue{public: virtual ~queue() {} virtual bool empty() const = 0; //判空 virtual int size() c...
复制链接

扫一扫

专栏目录