链队列的C++实现

#include<iostream>
using namespace std;
//节点类
template<class T>
struct QNode
{
	T data;
	QNode *next;
};
//队列类
template<class T>
struct LinkList
{
	QNode<T> * front;
	QNode<T> * rear;
	size_t size;
};

//构造一个空队列
template<class T>
void InitQueue(LinkList<T> & que)
{
	que.front = (QNode<T> *)malloc(sizeof(QNode<T>));
	if(!que.front) exit(0);
	que.size = 0;
	que.rear = que.front;
	que.rear->next = 0;
}
//销毁队列
template<class T>
void DestroyQueue(LinkList<T>& que)
{
	QNode<T> * p = que.front->next;
	free(que.front);
	while(p != 0)
	{
		que.front = p->next;
		free(p);
		p = que.front;
	}
}
//清空队列
template<class T>
void ClearQueue(LinkList<T>& que)
{
	QNode<T> * p = que.front->next;
	while(p != 0)
	{
		que.rear = p->next;
		free(p);
		p = que.rear;
	}
	que.rear = que.front;
	que.front->next = 0;
	que.size = 0;
}
//返回队列的长度
template<class T>
int QueueLength(LinkList<T>& que)
{
	return que.size;
}
//返回队列的队首元素
template<class T>
T GetHead(LinkList<T>& que)
{
	return que.front->next->data;
}
//元素入队
template<class T>
void EnQueue(LinkList<T>& que,T t)
{
	QNode<T> *p = (QNode<T>*)malloc(sizeof(QNode<T>));
	if(!p) exit(0);
	p->data = t;
	p->next = 0;
	que.rear->next = p;
	que.rear = p;
	que.size++;
}
//元素出队
template<class T>
bool DeQueue(LinkList<T>& que,T & t)
{
	if(que.size==0)
		return false;
	QNode<T> *p = que.front->next;
	que.front->next = p->next;
	que.size--;
	t = p->data;
	free(p);
	return true;
}
//从对头到队尾元素遍历调用visit函数
template<class T>
void VisitQueue(LinkList<T>& que,void (*visit)(T &t))
{
	QNode<T> *p = que.front->next;
	while(p != 0)
	{
		(*visit)(p->data);
		p = p->next;
	}
}
//测试函数
template<class T>
void Print(T &t)
{
	cout<<t<<endl;
}
template<class T>
void AddOne(T &t)
{
	t++;
}

int main()
{
//创建一个空的队列
	LinkList<int> queue;
//初始化队列
	InitQueue(queue);
//元素入队
	EnQueue(queue,1);
	EnQueue(queue,2);
	EnQueue(queue,3);
	EnQueue(queue,4);
//返回队列的长度
	cout<<"队列的长度:  "<<QueueLength(queue)<<endl;
//输出所有元素
	VisitQueue(queue,Print<int>);

//返回队列的队首元素
	cout<<"队列的队首元素:  "<<GetHead(queue)<<endl;
//元素出队
	int a ;
	if(DeQueue(queue,a))
	{
	  cout<<"出队元素:  "<<a<<endl;
	}
//返回队列的长度
	cout<<"队列的长度:  "<<QueueLength(queue)<<endl;
//输出所有元素
	VisitQueue(queue,Print<int>);
//元素出队
	if(DeQueue(queue,a))
	{
	  cout<<"出队元素:  "<<a<<endl;
	}
//返回队列的长度
	cout<<"队列的长度:  "<<QueueLength(queue)<<endl;
//输出所有元素
	VisitQueue(queue,Print<int>);

//将所有元素加一
	cout<<"将所有元素加一"<<endl;
	VisitQueue(queue,AddOne<int>);
//输出所有元素
	VisitQueue(queue,Print<int>);

//清空队列
	ClearQueue(queue);
//销毁队列
	DestroyQueue(queue);
}


链队列的C++实现

时间: 2024-10-26 06:23:37

链队列的C++实现的相关文章

链队列代码及应用

链队列代码 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <time.h> #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define TRUE 1 #define FALSE 0 typedef int Status; typedef int ElemType; typedef struct Qnode{ int

链栈和链队列的类实现

#include<iostream>#include<cassert> using namespace std; template <class T>//链栈 struct LinkNode{T data;LinkNode<T> *Link;LinkNode(LinkNode<T> *pr=NULL){Link=pr;}LinkNode(const T& item,LinkNode<T> *pr=NULL){data=item

09.循环队列与链队列

一.队列与循环队列 1.队列 (1)队列(queue)是只允许在一端进行插入操作,而在另一端进行删除操作的线性表.队列是一种先进先出(Fiirst In First Out)的线性表,简称FIFO.允许插入的一端称为队尾,允许删除的一端称为队头. 从队列的定义可知,队列的入队操作,其实就是在队尾追加一个元素,不需要移动任何元素,因此时间复杂度为O(1).队列的删除操作,与栈不同的是,队列元素的出列是在队头,即小标为0的位置,若要删除一个元素的话,需要移动队列的所有元素,因此事件复杂度为O(n).

链队列-C语言版

源文件部分: 指针没学好的同学很难看懂^_^,有点乱,希望对大家有点帮助. #include<stdio.h> #include<malloc.h> #include<stdlib.h> #include<string.h> typedef int Elemtype; #include"LQueue.h" int main() { Deque head; instruction(head); return 0; } 头文件部分: type

数据结构(C实现)------- 链队列

链队列,即队列的链式存储结构,它是仅在表头删除和表尾插入的单链表,因此一个链队列需要设置两个分别指示队头元素和队尾元素的指针,为了操作方便,给链队列添加一个头结点,并令队头指针指向头结点,由此,空的链队列的判断条件就是队头指针和队尾指针均指向头结点. 链队列的类型描述: //链队列类型描述 typedef int QElemType; typedef struct node{ QElemType data; struct node *next; }QNode,*QueuePtr; typedef

数据结构(二):链表、链队列

上一篇博文中主要总结线性表的顺序存储结构实现.比方顺序表.顺序队列和顺序栈.详细能够參考上篇博文 http://blog.csdn.net/lg1259156776/article/details/46993591 以下要进行学习和总结的是线性表的链式存储结构实现,比方链表和链队列. 顺序存储结构的优缺点 长处是逻辑相邻,物理相邻,可随机存取任一元素,存储空间使用紧凑:缺点是插入.删除操作须要移动大量的元素.平均移动n/2,预先分配空间需依照最大空间分配.利用不充分(C++ STL模板库中实现的

【算法设计-链栈和链队列】链栈和链队列的实现

1.链队列.利用带有头结点的单链表来实现链队列,插入和删除的复杂度都为o(1) 代码: #include<stdio.h> #include<stdlib.h> typedef struct Qnode { int data; Qnode *next; }Qnode; typedef struct LinkQueue { Qnode *front; Qnode *rear; }LinkQueue; void initialize(LinkQueue *LinkQueue) { Li

链队列的初始化、入队、出队等操作实现

链队列的初始化.入队.出队等基本操作实现代码如下: #include<iostream> using namespace std; #define  TRUE 1 #define  FALSE 0 //链队列定义 typedef struct Node { int data;//数据域 struct Node *next;//指针域 }LinkQueueNode; typedef struct { LinkQueueNode *front;//队头指针front LinkQueueNode *

java实现链队列

java实现链队列的类代码: package linkqueue; public class LinkQueue { class Element { Object elem; Element next; } private Element front; private Element rear; private Element header = null; /** * 初始化队列 * */ void initQueue() { header = new Element(); front = ne