数据结构之队列（参考王道书25数据结构）

最新推荐文章于 2024-06-15 16:46:40 发布
最新推荐文章于 2024-06-15 16:46:40 发布
阅读量306 收藏 1
点赞数 6
文章标签： 数据结构 c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/challenger_fight/article/details/137345878
版权

头文件

#include <stdio.h>
#include <stdbool.h>
#include <iostream>
#include <stdbool.h>
#include <algorithm>
#include <math.h>
#pragma warning(disable:4996)//忽略scanf，printf的检查
#pragma warning(disable:6011)//忽略空指针的赋值警告
using namespace std;
#define MaxSize 100

结构体定义

typedef struct {
	int data[MaxSize];
	int front, rear;
	int tag;//用于区分队满与队空,也可以用flag记录上一次操作，删除可能导致空，插入导致满

}SqQueue;

typedef struct {
	LinkNode * front, * rear;

}LinkQueue;

队列初始化

void InitQueue(LinkQueue& q)
{
	q.front = q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	q.front->next = NULL;

}

void InitQueue(SqQueue& q)
{
	q.rear = q.front = 0;
	q.tag = 0;
}

入队

void EnQueuelink(LinkQueue& q, int x)//带头结点
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	/*if (q.front == NULL)   //不带头指针的办法
	{
		q.front = s;
		q.rear = s;

	}
	else {
		q.rear->next = s;
		q.rear = s;
	}*/
	q.rear->next = s;//尾插
	q.rear = s;


}

出队

bool DeQueuelink(LinkQueue& q, int &x)
{
	if (q.rear == q.front)
		return false;
	LinkNode* p = q.front->next;//头节点
	x = p->data;
	q.front->next = p->next;
	if (q.rear == p)//删除的是最后一个结点时，做特殊处理
		q.rear = q.front;
	free(p);
	return true;

}

带tag的相关操作（判空，入队，出队）【这里tag也是size，与第一题不同】

bool QueneEmpty(SqQueue Q)
{
	if (Q.rear == Q.front)
		return true;
	else return false;

}
bool EnQueue(SqQueue& q, int x)
{
	if ((q.rear + 1) % MaxSize == q.front)return false;//但是牺牲一个存储单元用来判满
	q.data[q.rear] = x;
	q.rear = (q.rear + 1)%MaxSize;//循环队列的逻辑
	q.tag++;
	return true;

}
bool DeQuene(SqQueue& q, int& x)
{
	if (q.rear == q.front)
		return false;
	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.tag--;
	return true;

}

判空

bool QueneEmpty(SqQueue Q)
{
	if (Q.rear == Q.front)
		return true;
	else return false;

}

综合应用题

01

//01
int EnQueue1(SqQueue& q, int x)
{
	if (q.front == q.rear && q.tag == 1)//上一步为入队，此时头尾相遇必为满
		return 0;
	q.data[q.rear] = x;
	q.rear = (q.rear + 1) % MaxSize;
	q.tag = 1;return 1;

}
int DeQueue1(SqQueue& q, int &x)
{
	if (q.front == q.rear && q.tag == 0)//上一步为出队，此时头尾相遇必为空
		return 0;
	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.tag = 0;return 1;

}

02

//02
//思路很简单，队列元素出队后进栈再出栈
void inverse(SqStack& s, SqQueue& q)
{
	int x;
	while (!QueneEmpty(q))
	{
		 DeQuene(q,x);
		push(s, x);
}
	while (!StackEmpty(s))
	{
		pop(s, x);
		EnQueue(q, x);

	}


}

03

//03
//用两个栈模拟队列，注意元素的顺序，为了保证顺序，让一个栈存放输入，一个栈做出栈，两栈之间进行元素转移时要判断栈是否为空
int EnQueuewith2Stack(SqStack& s1, SqStack& s2, int e)
{
	int x;
	if (!StackOverflow(s1))
	{
		push(s1, e);
		return 1;
	}   if (StackOverflow(s1) && !StackEmpty(s2))
	{
		cout << "队列满";
		return 0;

	}    if (StackOverflow(s1) && StackEmpty(s2))
	{
		while (!StackEmpty(s1))
		{
			pop(s1, x);
			push(s2, x);


	}



}

	push(s1, e);
	return  1;


}
void  DeQueuewith2Stack(SqStack& s1, SqStack& s2, int &x)
{
	if (!StackEmpty(s2))
	{
		pop(s2, x);
		
	} else  if (StackEmpty(s1))
	{
		cout << "队列满";
	
	}  else 
	{
		while (!StackEmpty(s1))
		{
			pop(s1, x);
			push(s2, x);


		}

		pop(s2, x);

	}

	
	


}
int QueueEmptywith2Stack(SqStack s1, SqStack s2)
{
	if (StackEmpty(s1) && StackEmpty(s2))
		return 1;
	else
		return 0;




}

04

1.链式

2.

3.

4.

入队:if(front==rear->next){ 插入新节点 ; 保存入队元素；rear=rear->next;}（牺牲了一个单元做判断)

出队：if（front==rear）exit（-1）；【空】

取front所指的节点元素e；front=front->next;返回e；

代码全文【因含栈，队列与栈均放在一起】



#include <stdio.h>
#include <stdbool.h>
#include <iostream>
#include <stdbool.h>
#include <algorithm>
#include <math.h>
#pragma warning(disable:4996)//忽略scanf，printf的检查
#pragma warning(disable:6011)//忽略空指针的赋值警告
using namespace std;
#define MaxSize 100
typedef struct {
	int data[MaxSize];
	int top;


}SqStack;
typedef struct LinkNode {
	int data;
	struct LinkNode* next;



}LinkNode;
typedef struct {
	int data[MaxSize];
	int front, rear;
	int tag;//用于区分队满与队空,也可以用flag记录上一次操作，删除可能导致空，插入导致满

}SqQueue;

typedef struct {
	LinkNode * front, * rear;

}LinkQueue;
void InitQueue(LinkQueue& q)
{
	q.front = q.rear = (LinkNode*)malloc(sizeof(LinkNode));
	q.front->next = NULL;

}
void EnQueuelink(LinkQueue& q, int x)//带头结点
{
	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
	s->data = x;
	s->next = NULL;
	/*if (q.front == NULL)   //不带头指针的办法
	{
		q.front = s;
		q.rear = s;

	}
	else {
		q.rear->next = s;
		q.rear = s;
	}*/
	q.rear->next = s;//尾插
	q.rear = s;


}
bool DeQueuelink(LinkQueue& q, int &x)
{
	if (q.rear == q.front)
		return false;
	LinkNode* p = q.front->next;//头节点
	x = p->data;
	q.front->next = p->next;
	if (q.rear == p)//删除的是最后一个结点时，做特殊处理
		q.rear = q.front;
	free(p);
	return true;

}
void InitQueue(SqQueue& q)
{
	q.rear = q.front = 0;
	q.tag = 0;
}
bool QueneEmpty(SqQueue Q)
{
	if (Q.rear == Q.front)
		return true;
	else return false;

}
bool StackEmpty(SqStack s)
{
	if (s.top == -1)
		return true;
	else return false;



}
bool StackOverflow(SqStack s)
{
	if (s.top == MaxSize - 1)
		return true;
	else return false;



}
bool EnQueue(SqQueue& q, int x)
{
	if ((q.rear + 1) % MaxSize == q.front)return false;//但是牺牲一个存储单元用来判满
	q.data[q.rear] = x;
	q.rear = (q.rear + 1)%MaxSize;//循环队列的逻辑
	q.tag++;
	return true;

}
bool DeQuene(SqQueue& q, int& x)
{
	if (q.rear == q.front)
		return false;
	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.tag--;
	return true;

}
//01
int EnQueue1(SqQueue& q, int x)
{
	if (q.front == q.rear && q.tag == 1)//上一步为入队，此时头尾相遇必为满
		return 0;
	q.data[q.rear] = x;
	q.rear = (q.rear + 1) % MaxSize;
	q.tag = 1;return 1;

}
int DeQueue1(SqQueue& q, int &x)
{
	if (q.front == q.rear && q.tag == 0)//上一步为出队，此时头尾相遇必为空
		return 0;
	x = q.data[q.front];
	q.front = (q.front + 1) % MaxSize;
	q.tag = 0;return 1;

}
//02
//思路很简单，队列元素出队后进栈再出栈
void inverse(SqStack& s, SqQueue& q)
{
	int x;
	while (!QueneEmpty(q))
	{
		 DeQuene(q,x);
		push(s, x);
}
	while (!StackEmpty(s))
	{
		pop(s, x);
		EnQueue(q, x);

	}


}
//03
//用两个栈模拟队列，注意元素的顺序，为了保证顺序，让一个栈存放输入，一个栈做出栈，两栈之间进行元素转移时要判断栈是否为空
int EnQueuewith2Stack(SqStack& s1, SqStack& s2, int e)
{
	int x;
	if (!StackOverflow(s1))
	{
		push(s1, e);
		return 1;
	}   if (StackOverflow(s1) && !StackEmpty(s2))
	{
		cout << "队列满";
		return 0;

	}    if (StackOverflow(s1) && StackEmpty(s2))
	{
		while (!StackEmpty(s1))
		{
			pop(s1, x);
			push(s2, x);


	}



}

	push(s1, e);
	return  1;


}
void  DeQueuewith2Stack(SqStack& s1, SqStack& s2, int &x)
{
	if (!StackEmpty(s2))
	{
		pop(s2, x);
		
	} else  if (StackEmpty(s1))
	{
		cout << "队列满";
	
	}  else 
	{
		while (!StackEmpty(s1))
		{
			pop(s1, x);
			push(s2, x);


		}

		pop(s2, x);

	}

	
	


}
int QueueEmptywith2Stack(SqStack s1, SqStack s2)
{
	if (StackEmpty(s1) && StackEmpty(s2))
		return 1;
	else
		return 0;




}
bool GetHead(SqQueue q, int& x)
{
	if (q.rear = q.front)return false;
	x = q.data[q.front];
	return true;

	
}
//队列元素个数 （rear+MaxSize-front)%MaxSize
void InitStack(SqStack& s)
{
	s.top = -1;
}
bool push(SqStack& s, int x)
{
	if (s.top == MaxSize - 1)
		return false;
	/*s.top = s.top + 1;
	s.data[s.top] = x;*/
	s.data[++s.top] = x;
	return true;

}
bool pop(SqStack& s, int x)
{
	if (s.top ==- 1)
		return false;
	/* x=s.data[s.top];
	* s.top=s.top-1;
	*/
	 x=s.data[s.top--] ;
	return true;

}
bool Gettop(SqStack& s, int x)
{
	if (s.top == -1)
		return false;
	x = s.data[s.top];
	return true;

}
bool p03_2(char a[])
{
	int pushnum = 0;
	int popnum = 0;
	for (int i = 0;a[i] != '\0';i++)
	{
		if (a[i] == 'I')
		{
			pushnum++; continue;
		}
		if (a[i] == 'O')
		{
			popnum++;
			if(popnum>pushnum)
			{
				cout << "ERROR1";
				exit(-1);

			}
		}
	if(popnum!=pushnum)
	{
		cout << "ERROR2";
		exit(0);

	}
	return true;



}

}
typedef struct LNode {

	char data;
	struct LNode* Next;

}LNode, * LinkList;

bool p04(LinkList l, int n)
{
	int i;
	LNode* p = l->Next;
	char *s=new char[n/2] ;
	for ( i = 0;i < n / 2;i++)
	{
		s[i] = p->data;
		p = p->Next;

	}
	i--;
	if (n % 2 == 1)
		p = p->Next;
	while (p != NULL && s[i] == p->data)
	{
		i--;
		p = p->Next;

	}
	if (i == -1)return true;
	else return false;
}

typedef struct {
	int stack[MaxSize];
	int top[2];
}stk;
stk s;

int stkpush(int i, int x)
{
	if (i < 0 || i>1) {
		printf("error");
		exit(0);
	}
	if(s.top[1]-s.top[0]==1)
	{
		printf("full");
		return 0;
	}
	switch (i)
	{
	case 0:s.stack[++s.top[0]] = x; return 1; break;
	case 1:s.stack[--s.top[1]] = x;return 1;


	}

}
int stkpop(int i)
{
	if (i < 0 || i>1)
	{
		printf("error");
		exit(0);
	
	}switch (i)
	{
	case 0:if (s.top[0] == -1) return -1; else return s.stack[s.top[0]--];  break;
	case 1:if (s.top[1] == MaxSize) return -1; else return s.stack[s.top[1]++];  



}

 }
int main()
{
   cout << "Hello World!\n";
}

真*小白
关注
  • 6
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
数据结构PPT.pptx
01-19
本PPT讲义主要介绍了数据结构的基本概念、数组、链表、栈、队列、树、图等数据结构的实现和应用，以及KMP算法、朴素模式匹配算法等字符串匹配算法的介绍和分析。 KMP算法是由D.E.Knuth、J.H.Morris和V.R.Pratt三人...
考研专业课-数据结构-思维导图
12-30
打开方式：Freemind、幕布等思维导图软件  “数据结构”是计算机、...资源中包含数据结构绪论，线性表，栈、队列和数组，串，树与二叉树，即王道书前五章内容，均为本人考研过程中自己整理总结。后续内容会逐步更新。
数据结构c语言代码（devc++版）
07-27
里面包含了数据结构c语言示例代码，且用了c++引用，与王道书基本一致，仅供参考。 包括 顺序表 链表 栈 队列 树 查找 排序 串
数据结构考试大纲、PTA答案与解析
10-05
大纲和PTA解析可以看看，其他资料没太有参考性，可以看看《王道考研数据结构》，讲的比较清楚
《征服数据结构》栈
数据结构和算法
06-12 214
摘要：1，栈的介绍2，栈的链表实现3，栈的数组实现1，栈的介绍栈(stack)又称堆栈，是一种特殊的线性表，只能对栈顶添加和删除元素，它是一种后进先出(LIFO, Last In First Out)的数据结构。栈的两种基本操作：压栈(push)和出栈(pop)。压栈：将数据放入堆栈顶端。出栈：将堆栈顶端数据移除。堆栈只能操作一端，我们前面讲过双端队列，就是两端都可以添加和删除元素，如果把双端队列...
Python基础教程（十一）：数据结构汇总梳理
菜鸟小码的博客
06-11 1209
本文将深入探讨Python中的主要数据结构类型，包括列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set），并通过具体案例来展示它们的应用场景。
数据结构(4):串
qq_64279967的博客
06-10 499
字符串数据结构三要数：逻辑结构、存储结构、运算子串必须是连续的！空格也是一个字符！每个空格字符占1B。
二叉树顺序结构——堆的结构与实现
qq3304968099的博客
06-10 878
二叉树顺序结构——堆的结构与源代码实现
【数据结构（邓俊辉）学习笔记】图04——双连通域分解
weixin_44399845的博客
06-10 979
双连通分量 BCC 双连通域
[C][数据结构][排序][下][快速排序][归并排序]详细讲解
SnowK博客
06-14 4510
[C][数据结构][排序][下][快速排序][归并排序]详细讲解
数据结构进阶——AVL树
weixin_73870552的博客
06-09 1073
学习本章，需要大家先掌握搜索二叉树，了解键值对pair。int _bf;// balance factor 平衡因子, _kv(kv), _bf(0){}该节点的定义是一个三叉链，_left和_right分别指向左右子树，_parent指向父节点；节点中存储的有效数据为pair，类型的键值对；_bf为平衡因子，在此我们定义为右树高度减去左树高度，用来控制左右子树的高度（注意：平衡因子只是其中一种控制平衡的手段，并不是唯一的）；定义了一个模版构造函数，以便后续使用。
Day01 数据结构概述
qq_59111928的博客
06-13 446
数据：能被计算机存储和识别的信息。文字、图形、视频、音频数据结构：计算机存储数据和组织数据的方式。
【数据结构（邓俊辉）学习笔记】图05——优先级搜索
weixin_44399845的博客
06-10 561
优先级搜索 PFS
牛客题目数据结构
Lanthamum的博客
06-10 291
对了还需要看一下变化量有没有用到其他维护量，如果有要把维护量放在后面更新。做过线段树2模板大概可以写出一部分代码，这题主要关键点是怎么维护平方和。感觉这类题只要数学处理出得到懒标记后，式子变化量是什么就可以了。这样处理完maketag的代码就出来了。
【C++提高编程-05】----C++之Deque容器实战
最新发布
一伦明悦的博客
06-15 900
Deque（双端队列）是C++ STL中的一种序列容器
【C++】——Stack与Queue（含优先队列（详细解读）
m0_74092462的博客
06-09 1035
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
【C语言】一维数组（详解）
lrq13965748542的博客
06-11 1010
有了下标引用操作符，我们可以轻松访问到数组中的元素了，比如我们访问下标为7的元素，我们就可以使用 arr[7]，想要访问下标为3的元素，就使用 arr[3]。我们知道数组中所有元素的类型都是相同的，那只要计算出一个元素所占字节的个数，数组的元素个数就能计算出来。以后在代码中需要数组元素个数的地方就不用固定写死了，使用上面的计算，不管数组怎样变化，计算出的大小也就随着变化了。数组也是有类型的，数组算是一种自定义类型，去掉数组名留下的就是数组的类型。实现了数组的访问，现在我们也可以实现对数组中进行数据的输入。
【2024最新华为OD-C/D卷试题汇总】[支持在线评测] CPU算力分配(100分) - 三语言AC题解(Python/Java/Cpp)
清隆学长的博客
06-11 396
### 问题描述 K小姐是某公司运营部门的主管,最近她需要对公司的两组服务器进行算力分配。每组服务器有多个算力不同的 $CPU$,其中 $A$ 组第 $i$ 个 $CPU$ 的运算能力为 $A[i]$,而 $B$ 组第 $i$ 个 $CPU$ 的运算能力为 $B[i]$。一组服务器的总算力是各 $CPU$ 的算力之和。 为了让两组服务器的算力相等,K小姐允许从每组各选出一个 $CPU$ 进行一次交换。她希望从 $A$ 组服务器中选出算力尽可能小的 $CPU$ 来交换,你能帮她计算出应该选择哪两个 $CP
王道数据结构的书怎么用
10-14
王道数据结构是一本比较经典的数据结构教材，主要讲解了数据结构的基本概念、线性表、栈和队列、串、树、图等内容。如果你想学习数据结构，可以按照以下步骤使用这本书： 1. 先阅读第一章，了解数据结构的基本概念...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值