精华内容
下载资源
问答
  • 2021-11-18 19:53:02
    #include <iostream>
    #include <stdlib.h>
    #define OVERFLOW -2
    //#define true 1
    //#define false -1
    
    using namespace std;
    typedef int QElemType;
    // 结点定义
    typedef struct QNode {
    	QElemType data; // 数据域
    	struct QNode *next; // 指针域
    }*QueuePtr;
    // 链队列定义
    typedef struct {
    	QueuePtr front; // 队列的头指针
    	QueuePtr rear; // 队列的尾指针
    	int length;
    }Queue; // 链队列
    //始化链队列为空队列
    bool InitQueue(Queue &Q)
    {
    	Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));//为空的标志就是头指针与尾指针相等
    	if (!Q.front)exit(OVERFLOW);
    	Q.front->next = NULL;
    	return true;
    }
    //新元素 e 入队列,成功返回 true,失败返回 false 
    bool EnQueue(Queue &Q, QElemType e)
    {
    	QNode *p;//先定义一个指向新结点的指针
    	p = (QueuePtr)malloc(sizeof(QNode));
    	if (!p)exit(OVERFLOW);
    	p->data = e;
    	p->next = NULL;
    	Q.rear->next = p;//只能从队尾进
    	Q.rear = p;//改变尾指针
    	return true;
    }
    //出队列,即删除队首元素,并用 e 返回出元素值 ,成功返回 true,失败返回 false 
    bool DeQueue(Queue &Q, QElemType &e)
    {
    	if (Q.front == Q.rear)
    		return false;
    	QNode *p;//指向被删除元素
    	p = Q.front->next;//因为只能从队列前面删除
    	e = p->data;
    	cout << "出队元素是" << e;
    	Q.front->next = p->next;
    	if (Q.rear == p)Q.rear = Q.front;//但当队列中最后一个元素被删后,队列尾指针也丢失了,需要将队尾指针指向头结点
    	free(p);
    	return e;
    }
    //读队首元素,用 e 返回队首元素,不出队 ,成功返回 true,失败返回 false 
    bool GetHead(Queue &Q, QElemType &e)
    {
    	if (Q.front == Q.rear)
    		return false;//判断是否为空
    	QNode *p;//指向被删除元素
    	p = Q.front->next;//因为只能从队列前面删除
    	e = p->data;
    	cout << "队首元素是"<<e;
    	return true;
    }
    //遍历链队列,将队列数据元素依次输出
    void Traverse(Queue Q)
    {
    	
    	while (Q.front!=Q.rear) {//之前一直写的条件是Q.front!=NULL;一直有问题
    
    		
    		Q.front = Q.front->next;
    		cout << Q.front->data << " ";
    
    
    	}
    }
    //销毁链队列
    void Destroy(Queue &Q)
    {
    	while (Q.front)//从头指针出队列删除元素
    	{
    		Q.rear = Q.front->next;//先把Q.front指向的下一个指针地址保存到尾指针
    		free(Q.front);//从前面出队列
    		Q.front = Q.rear;//头指针改变位置
    
    	}
    
    	
    }
    int main(void)
    {
    	Queue Lque;
    	int c = 0;
    	QElemType e;
    	while (c != 7)
    	{
    		cout << endl << "1. 初始化链队";
    		cout << endl << "2. 入队";
    		cout << endl << "3. 出队";
    		cout << endl << "4. 读队首";
    		cout << endl << "5. 遍历队列";
    		cout << endl << "6. 销毁队列";
    		cout << endl << "7. 退出";
    		cout << endl << "选择功能(1~7):";
    		cin >> c;
    		switch (c)
    		{
    		case 1:
    		{
    			InitQueue(Lque);
    			
    			break;
    		}
    		case 2:
    		{
    			cout << "请输入要入队的元素e";
    			cin >> e;
    			EnQueue(Lque, e);
    			
    			break;
    		}
    		case 3:
    		{
    			DeQueue(Lque, e);
    			
    			break;
    		}
    		case 4:
    		{
    			GetHead(Lque, e);
    			break;
    		}
    		case 5:
    		{
    			Traverse(Lque);
    			break;
    		}
    		case 6:
    		{
    			Destroy(Lque);
    			break;
    		}
    		case 7:
    		{
    			break;
    		}
    		}
    	}
    }

    更多相关内容
  • 本程序共设计了顺序队列需要的的5个基本操作运算,分别是入队,出队,取对头元素,置空队列,输出队列。附带实验报告。
  • 队列基本操作 C++

    2020-05-21 13:06:32
    #include <iostream> using namespace std; //定义结点 typedef struct QNode { int data; QNode* next; }QNode, * QueuePtr;...//初始化队列 void Init(LQueue& Q) { Q.front = Q.rear = new QNod
    #include <iostream>
    using namespace std;
    
    //定义结点
    typedef struct QNode
    {
    	int data;
    	QNode* next;
    }QNode, * QueuePtr;
    //定义链队
    struct LQueue
    {
    	QNode* front;	//队头结点
    	QNode* rear;	//队尾节点;
    };
    //初始化队列
    void Init(LQueue& Q)
    {
    	Q.front = Q.rear = new QNode;
    	Q.front->next = nullptr;
    }
    
    //入队列
    void enQueue(LQueue& Q)
    {
    	int n;
    	
    	cout << "请输入需要添加的元素个数:" << endl;
    	cin >> n;
    	cout << "请输入需要添加的元素:" << endl;
    	for (int i = 0; i < n; i++)
    	{
    		QueuePtr p = new QNode;
    		cin >> p->data;
    		p->next = nullptr;
    		Q.rear->next = p;
    		Q.rear = p;
    	}
    }
    //判断队列是否为空
    bool isEmpty(LQueue Q)
    {
    	if (Q.front->next == nullptr)
    		return true;
    	return false;
    }
    //出队列
    void deQueue(LQueue& Q)
    {
    	int n;
    	cout << "请输入需要删除的数字个数:" << endl;
    	cin >> n;
    	for (int i = 0; i < n; i++)
    	{
    		if (isEmpty(Q))
    		{
    			cout << "队列为空" << endl;
    			return;
    		}
    		QueuePtr p = new QNode;
    		p = Q.front->next;
    		cout << "已删除元素:" << p->data << endl;
    		Q.front->next = p->next;
    		delete(p);
    	}
    }
    
    //遍历队列
    void displayQueue(LQueue Q)
    {
    	QueuePtr p = Q.front->next;
    	while (p != nullptr)
    	{
    		cout << p->data << " ";
    		p = p->next;
    	}
    	cout << endl;
    	return;
    }
    
    //获取队顶元素
    void getHead(LQueue Q)
    {
    	if (isEmpty(Q))
    	{
    		cout << "队列为空" << endl;
    		return;
    	}
    	cout << "队顶元素为:" << Q.front->next->data << endl;
    }
    void clearQueue(LQueue& Q)
    {
    	QueuePtr p, q;
    	p = Q.front->next;
    	Q.front->next = nullptr;
    	while (p)
    	{
    		q = p->next;
    		delete(p);
    		p = q;
    	}
    	Q.rear = Q.front;
    	return;
    }
    //销毁队列
    void destroyQueue(LQueue& Q)
    {
    	while (Q.front)
    	{
    		Q.rear = Q.front->next;
    		delete(Q.front);
    		Q.front = Q.rear;
    	}
    }
    //获取队列长度
    void lengthQueue(LQueue Q)
    {
    	int cnt = 0;
    	QueuePtr p = Q.front->next;
    	while (p != nullptr)
    	{
    		cnt++;
    		p = p->next;
    	}
    		
    	cout << "队列长度为:" << cnt << endl;
    }
    //菜单
    void menu()
    {
    	cout << "********1.入队           2.出队*********" << endl;
    	cout << "********3.取队顶元素     4.遍历队列*****" << endl;
    	cout << "********5.清空队列       6.销毁队列*****" << endl;
    	cout << "********7.队列长度       8.退出*********" << endl;
    }
    int main()
    {
    	LQueue queue;
    	int choice;
    	Init(queue);
    	while (1)
    	{
    		menu();
    		cin >> choice;
    		if (choice == 8)
    			break;
    		switch (choice)
    		{
    		case 1:
    			enQueue(queue); break;
    		case 2:
    			deQueue(queue); break;
    		case 3:
    			getHead(queue); break;
    		case 4:
    			displayQueue(queue); break;
    		case 5:
    			clearQueue(queue); break;
    		case 6:
    			destroyQueue(queue); break;
    		case 7:
    			lengthQueue(queue); break;
    		default:
    			break;
    		}
    	}
    	return 0;
    }
    
    展开全文
  • //链队列 typedef int DataType; #define Node ElemType class Node { public: DataType data;//结点数据域 ElemType *next;//结点指针域 };//定义一个结点类(链类需要) class QueueLinkList { public: ...
    #include <iostream>
    using namespace std;
    //链队列
    typedef int DataType;
    #define Node ElemType
    
    class Node
    {
    public:
    	DataType data;//结点数据域
    	ElemType *next;//结点指针域
    };//定义一个结点类(链类需要)
    
    class QueueLinkList 
    {
    public:
    	QueueLinkList();				//初始化队列
    	~QueueLinkList();				//摧毁队列
    	int IsEmpty();					//判断队列是否为空
    	void Enqueue(DataType data);	//入队
    	void Dequeue();					//出对
    	void PrintfQueue();				//打印队列
    private:
    	ElemType *front;//对头指针
    	ElemType *rear;//队尾指针
    };
    
    //初始化队列
    QueueLinkList::QueueLinkList()
    {
    	front = new ElemType;//使对头指针指向新创建的结点
    	front->data = 0;//为队头指针的数据域赋值
    	front->next = NULL;//指向下一个为空
    	rear = front;//队头与队尾重合
    }
    
    //摧毁队列
    QueueLinkList::~QueueLinkList()//析构函数实现
    {
    	delete front;
    }
    
    //判断队列是否为空
    int QueueLinkList::IsEmpty()
    {
    	return front->next == NULL;//下一个指针域为空,数据域没值
    }
    
    //入队
    void QueueLinkList::Enqueue(DataType data)
    {
    	ElemType *newNode = new ElemType;//每次入队都要新创一个结点
    	newNode->data = data;//为新创建的数据域赋值
    	newNode->next = NULL;//然后将下一个指针域置空
    	rear->next = newNode;//使队尾指针指向新创建的结点
    	rear = newNode;//使新创建的结点成为队尾
    }
    
    //出队
    void QueueLinkList::Dequeue()
    {
    	if (front->next == NULL)
    	{
    		cout << "队为空" << endl;
    	}
    	ElemType *ptemp = front->next;//先进先出,创建一个新的指针承接第二个位置的指针域
    	front->next = ptemp->next;//使指向第二个元素的指针变成指向第三个元素的指针
    	delete ptemp;//删除新创建的,然后就完成了对头指针的交接
    }
    
    //遍历队列
    void QueueLinkList::PrintfQueue()
    {
    	ElemType *p = front;//使新创建的指向对头
    	if (front->next == NULL)
    	{
    		cout << "队为空" << endl;
    		return;
    	}
    	while (p->next != NULL)
    	{
    		p = p->next;//逐个指向
    		cout << p->data << " ";//逐个输出完成遍历打印
    	}
    	cout << endl;
    }
    
    //测试函数
    int main()
    {
    	QueueLinkList q;//创建对象q
    	int i;
    	cout << "1.判断队是否为空   2.入队   3.出队   4.打印队   0.退出" << endl;
    	do//循环函数加开关函数巧妙完成
    	{
    		cout << "请输入要执行的操作:";
    		cin >> i;
    		switch (i)
    		{
    		case 1:
    			if (q.IsEmpty() == 1)
    				cout << "空队" << endl;
    			else
    			{
    				cout << "不是空队" << endl;
    			}
    			break;
    		case 2:
    			int n;
    			cout << "请输入要入队的值(一次只能入一个值哦):";
    			cin >> n;
    			q.Enqueue(n);
    			break;
    		case 3:
    			q.Dequeue();
    			break;
    		case 4:
    			cout << "打印队列" << endl;
    			q.PrintfQueue();
    			break;
    		default:
    			cout << "输入的操作值错误" << endl;
    			break;
    		}
    	} while (i != 0);
    	system("pause");
    	return 0;
    }
    
    
    
    展开全文
  • 队列基本操作C/C++代码实现

    千次阅读 多人点赞 2020-06-03 20:47:23
    队列的结构: 链队列与单链表相同但与链栈不同的是,链队列需要添加一个头结点,并让头指针始终指向头结点。 入队: 链队列也不需要判断队满。 出队: 链队列队空条件:Q.front==Q.rear (与循环队列形式相同) ...

    链队列的结构:

    在这里插入图片描述
    链队列与单链表相同但与链栈不同的是,链队列需要添加一个头结点,并让头指针始终指向头结点。

    入队:

    链队列也不需要判断队满。
    在这里插入图片描述

    出队:

    链队列队空条件:Q.front==Q.rear (与循环队列形式相同)
    在这里插入图片描述
    需要特别注意的是:需要判断出队元素是否为最后一个元素,若是,则将队尾指针重新赋值, 指向头结点。 (否则尾指针将丢失)

    代码如下:

    #include<stdio.h>
    #include<stdlib.h>
    
    #define MAXQSIZE 100
    typedef int QElemType;
    
    //链队列的结构
    typedef struct QNode
    {
    	QElemType data;
    	struct QNode *next;
    }QNode,*QueuePtr;
    typedef struct
    {
    	QueuePtr front;			//头指针
    	QueuePtr rear;			//尾指针
    }LinkQueue;
    
    //初始化
    void InitQueue(LinkQueue &Q)
    {
    	Q.front = new QNode;		//创建一个头结点
    	Q.rear = Q.front;			//头尾指针都指向头结点
    	Q.front->next = NULL;		
    }
    
    //入队
    int EnQueue(LinkQueue &Q,QElemType e)
    {
    	//链队列不需要判断队满
    
    	QNode *p = new QNode;
    	p->data = e;
    	p->next = NULL;
    	Q.rear->next = p;
    	Q.rear = p;
    	return 1;
    }
    
    //出队
    int DeQueue(LinkQueue &Q, QElemType &e)
    {
    	if (Q.rear == Q.front) return 0;   //队空
    
    	QNode *p = Q.front->next;
    	e = p->data;
    	Q.front->next = p->next;
    	if (Q.rear == p) Q.rear = Q.front;		//注意:最后一个元素被删, 队尾指针也要指向头结点 
    	delete p;
    	return 1;
    }
    
    //取队头元素
    QElemType GetHead(LinkQueue Q)
    {
    	if (Q.front != Q.rear)			//非空时 取值
    		return Q.front->next->data;
    }
    
    //遍历输出队列
    void printQueue(LinkQueue Q)
    {
    	printf("队头->");
    	QNode *p =Q.front->next;
    	while (p)
    	{
    		printf("%d ", p->data);
    		p = p->next;
    	}
    	printf("<-队尾\n");
    }
    
    
    int main()
    {
    	LinkQueue Q;
    	int e;
    	InitQueue(Q);
    	printf("请输入一个要入队的元素(-1表示结束):");
    	scanf("%d", &e);
    	while (e != -1)
    	{
    		EnQueue(Q, e);
    		printf("请输入一个要入队的元素(-1表示结束):");
    		scanf("%d", &e);
    	}
    	printQueue(Q);
    	printf("出队测试:");
    	DeQueue(Q, e);
    	printQueue(Q);
    
    	printf("取队头元素测试:");
    	e = GetHead(Q);
    	printf("取出的队头元素为:%d\n", e);
    }
    

    运行结果:

    在这里插入图片描述

    展开全文
  • c++实现队列基本操作

    千次阅读 2022-03-18 15:27:42
    使用c++简单实现队列的删除,插入,判空,大小的模板。 template<typename T> class queue { private: struct queueNode { T data; queueNode* next; queueNode(T x) :data(x), next(nullptr) {}; }; ...
  • 栈和队列的概念及基本操作/C++

    千次阅读 2019-11-21 21:28:17
    栈和队列的定义及基本操作 一、栈 1、栈的定义: 对于由n个数据元素构成的一个线性序列,如果只允许在其指定的一端插入或删除一个数据元素,那么这种逻辑结构称为栈(Stack)或堆栈。 栈是一种”先进后出“(First ...
  • 顺序队列基本操作实现c++

    千次阅读 2016-08-06 20:51:36
    注:若有错误或需要补充的内容请告之,新手上路,谢谢。 #include #include #include #include #include #include #include .../*************循环队列结构体****************/ typedef struct lnode {
  • c++,链队列基本操作(创建,销毁,查找,删除,插入等)
  • (1)初始化顺序栈; (2)数据元素入栈; (3)数据元素出栈; (4)读栈顶元素;...ps: 数据结构实验作业,感觉有错,希望大家批评...//顺序队列基本操作 #define OK 1; #define ERROR 0; #define MAXQSIZE 100 ..
  • 事实上,队列的确与栈非常类似,但它只允许在表的前端(front)进行删除操作,而在表的后端(rear)进行插入操作,和栈一样,队列是一种操作受限制的线性表。进行插入操作的端称为队尾,进行删除操作的端称为队头。 ...
  • 数据结构中循环队列基本操作,分享一下,欢迎大家批评指正!
  • 队列基本操作(C/C++)

    2021-10-18 17:42:52
    队列:只允许在一端进行插入操作,而在另一端进行删除操作的线性表---->先进先出FIFO 允许插入(也称入队,进队)的一端称为队尾 允许删除(出队)的一端称为队头 二、顺序队列 顺序队列:利用数组实现队列的...
  • 【源代码】C++算法(四)队列基本操作 (用队列实现十进制转换十六进制)
  • 参考:数据结构图文解析之:队列详解与C++模板实现 队列简介 队列(Queue)特点: 1、队列中的数据元素遵循“先进先出”(First In First Out)的原则,简称FIFO结构。...队列基本操作: q.empty() 如果队列为...
  • C++实现循环队列

    2020-08-25 03:51:15
    主要为大家详细介绍了C++实现循环队列,文中示例代码介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C++数据结构——队列的创建和基本操作
  • 代码由C++程序设计语言编写,包含栈和队列基本操作(栈:出、入、取、判空等|队列:出、入、取、打印队列、判空等),并展示了三个具体的使用例子,包括用栈求进制转换和用队列打印杨辉三角形,以及用栈计算后缀...
  • C++队列基本操作

    千次阅读 2019-06-07 11:50:41
    相关概念 队列:只允许在一段进行插入操作,而在另一端进行删除操作的线性表 性质:先进先出 常见操作
  • C++: 队列及其操作

    2021-07-19 12:49:23
    内存限制:128 MiB 时间限制:1000 ms 标准输入输出 题目类型:传统 评测方式:文本比较 题目描述 队列(queue):在线性表的一端...第1行包含一个整数,表示有条关于queue的操作,在进行任何操作之前,queue...
  • 自己写的队列基本操作。比较通俗易懂。用c++实现的。
  • C++队列操作

    2021-05-06 21:24:40
    C++队列操作 队列:只允许在表的一端(队头)进行插入操作,在另一端(队尾)进行删除操作 队列操作特性:先进先出(First In First Out,FIFO) 顺序队列:具有单向移动性,会造成假溢出。 假溢出:数组空间...
  • C++队列queue基本操作

    万次阅读 多人点赞 2018-03-15 13:00:19
    http://blog.csdn.net/cindywry/article/details/51919282C++队列queue模板类的定义在&lt;queue&gt;头文件中,queue 模板类需要两个模板参数,一个是元素类型,一个容器类型,元素类型是必要的,...C++队列...
  • 两种方法实现了队列操作,链表and容器(容器实现循环队列) 1.实现队列的一种存储结构 2.实现队列的相关操作 3.利用队列操作特点,借助进队与出队操作完成打印二项式系数的任务(杨辉三角)
  • 编写程序,建立容量为n(建议n=8)的循环队列,完成以下程序功能。输入字符#,执行一次出队操作,屏幕上显示出队字符;输入字符@,队列中所有字符依次出队并按出队次序在屏幕上显示各字符;输入其它字符,则输入的字符...
  • C++栈与队列基本操作

    2017-05-31 21:13:47
    使用标准库的栈和队列时,先包含相关的头文件 #include #include ...栈提供了如下的操作 [cpp] view plain copy s.empty() 如果栈为空返回true,否则返回false  s
  • C++队列基本用法

    2021-05-17 20:59:26
    C++队列的用法 队列的数据结构 ADT 队列(Queue) Data 同线性表。具有相同的数据类型,相邻的元素存在前驱和后继关系 Opreation InitQueue(): 初始化一个空的队列 DestoryQueue(): 销毁队列 ClearQueue():...
  • 栈和队列基本操作c++实现)

    千次阅读 2020-04-15 22:23:34
    (2)编程实现循环队列和链队列基本操作:建队列,取队头元素,入队,出队。 1.顺序栈 #include<iostream> using namespace std; #define MAXSIZE 5 typedef struct{ int *base; int *top; int stac...
  • 队列(queue):先进先出的一种数据结构(First In First Out)。 que.empty():队列空返回1,否则返回0。 que.size():返回队列的数据个数。 que.front():访问队头元素。 que.back():访问队尾元素。 que.push():入...
  • 循环队列基本操作C/C++代码实现

    千次阅读 2020-06-03 18:27:51
    在非空队列中,头指针始终指向队列头元素,而尾指针始终指向队列尾元素的下一个位置,阴影部分表示队列: 另外通过取模,头指针和尾指针就可以在顺序表空间内以头尾衔接的方式 ”循环" 移动。(为了防止假溢出) ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 84,712
精华内容 33,884
关键字:

队列的基本操作c++

c++ 订阅
友情链接: fanjing.zip