C++数据结构与算法（栈和队列）

最新推荐文章于 2024-06-04 08:22:26 发布
最新推荐文章于 2024-06-04 08:22:26 发布
阅读量2.2k 收藏 39
点赞数 7
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_37753215/article/details/98097796
版权

目录

1栈

1.1栈定义

1.2栈的表示和实现

1.2.1顺序栈

1.1.2链栈

1.3栈的应用——括号匹配问题

2队列

2.1队列的定义

2.2队列的表示和实现

2.2.1链队列

2.2.2循环队列

2.3队列的应用——约瑟夫环问题

1栈

1.1栈定义

       栈（stack）作为一种限定性线性表，是将线性表的插入和删除运算限制为仅在表的一端进行，通常将表中允许进行插入、删除操作的一端称为栈顶（Top），因此栈顶的当前位置是动态变化的，它由一个称为栈顶指针的位置指示器指示。同时表的另一端被称为栈底（Bottom）。当栈中没有元素时称为空栈。栈的插入操作被形象地称为进栈或入栈，删除操作称为出栈或退栈。

       栈有时叫做LIFO（后进先出）表。一般的模型是，存在某个元素位于栈顶，而该元素是唯一的可见元素。

1.2栈的表示和实现

        栈作为一种特殊的线性表，在计算机中主要有两种基本的存储结构：顺序存储结构和链式存储结构。我们称顺序存储的栈为顺序栈，链式存储的栈为链栈。

1.2.1顺序栈

        顺序栈是用顺序存储结构实现的栈，即利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，同时由于栈操作的特殊性，还必须附设一个位置指针top（栈顶指针）来动态地指示栈顶元素在顺序栈中的位置。通常以top=-1表示空栈。顺序栈的存储结构的进栈和出栈过程如下图：

/*顺序栈实现*/
#include<iostream>
using namespace std;

//元素elem进栈
int push(int* a, int top, int elem){
	a[++top] = elem;
	cout << "入栈元素：" << a[top] << endl;
	return top;
}
//数据元素出栈
int pop(int * a, int top){
	if (top == -1) {
		printf("空栈\n");
		return -1;
	}
	printf("弹栈元素：%d\n", a[top]);
	top--;
	return top;
}
int main() {
	int a[100];
	int top = -1;
	top = push(a, top, 1);
	top = push(a, top, 2);
	top = push(a, top, 3);
	top = push(a, top, 4);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	top = pop(a, top);
	system("pause");
	return 0;
}

结果：

1.1.2链栈

       链栈即采用链表作为存储结构实现的栈。由于栈的插入和删除操作仅限在表头仅限，所以链表的表头指针就作为栈顶指针。

链栈示意图：

链栈的实现：

#include<iostream>
using namespace std;

typedef struct lineStack{
	int data;
	struct lineStack * next;
}lineStack;

lineStack* push(lineStack * stack, int a){
	lineStack * line = (lineStack*)malloc(sizeof(lineStack));
	line->data = a;
	line->next = stack;
	stack = line;
	cout << "入栈元素：" << line->data << endl;
	return stack;
}

lineStack * pop(lineStack * stack){
	if (stack) {
		lineStack * p = stack;
		stack = stack->next;
		printf("弹栈元素：%d ", p->data);
		if (stack) {
			printf("栈顶元素：%d\n", stack->data);
		}
		else{
			printf("栈已空\n");
		}
		free(p);
	}
	else{
		printf("栈内没有元素\n");
		return stack;
	}
	return stack;
}

/*求栈长*/
int lengthStack_L(lineStack *S)

{
	lineStack *q;
	int count;
	q = S;
	count = 0;
	while (q)
	{
		++count;
		q = q->next;
	}
	return count;
}

int main() {
	int len;
	lineStack * stack = NULL;
	stack = push(stack, 1);
	stack = push(stack, 2);
	stack = push(stack, 3);
	stack = push(stack, 4);
	len = lengthStack_L(stack);
	cout << "栈链长度为：" << len << endl;
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	stack = pop(stack);
	system("pause");
	return 0;
}

结果：

1.3栈的应用——括号匹配问题

#include <iostream>
#include <stack>
#include <string>
using namespace std;

bool paren(const std::string &str)
{
	std::stack<char> s;
	for (auto i = 0; i < str.size(); i++)
	{
		switch (str[i])
		{
		case '(':s.push(str[i]); break;
		case '[':s.push(str[i]); break;
		case '{':s.push(str[i]); break;
		case ')':
			if (s.top() != '(')
				return false;
			else
				s.pop(); break;
		case ']':
			if (s.top() != '[')
				return false;
			else
				s.pop(); break;
		case '}':
			if (s.top() != '{')
				return false;
			else
				s.pop(); break;

		default:
			break;
		}
	}
	return s.empty();
}

int main()
{
	//string strBuf = "()[]{}[()]";
	char strBuf[50];
	cin >> strBuf;
	cout << endl;
	cout << "The string is : " << strBuf << " ";
	if (paren(strBuf))
		cout << "括号匹配";
	else
		cout << "括号不匹配";
	cout << endl;
	system("pause");
	return 0;
}

结果：

2队列

2.1队列的定义

         队列（Queue）是另一种限定性的线性表，它只允许在表的一端插入元素，而在另一端删除元素，所以队列具有先进先出（FIFO）的特性。

2.2队列的表示和实现

          与线性表类似，队列也可以有两种存储表示，即顺序表示和链式表示。

2.2.1链队列

        用链表表示的队列简称为链队列。如下图所示，队头指针始终指向头节点，队尾指针指向当前最后一个元素。空的链队列的队头指针和队尾指针均指向头节点。

  • 初始化队列时，令front=rear=0；
  • 入队时，直接将新元素送入尾指针rear，所指的单元，然后尾指针增加1；
  • 出队时，直接取出队头指针front所指的元素，然后头指针增加1.

           显然，在非空顺序队列中，队头指针始终指向当前的队头元素，而队尾指针始终指向真正队尾元素后面的单元。当rear== MAXSIZE时，认为队满，因为随着部分元素的出队，数组前面会出现一些空单元。由于只能在队尾入队，使得这些空单元无法使用。这种现象被称为假溢出，真正队满的条件时rear-front=MAXSIZE.

顺序队列的实现：

#include<iostream>
using namespace std;
#define N 4

int in(int *s, int rear, int x)
{
	rear = (rear + 1) % (N + 1);
	s[rear] = x;
	return rear;
}

int out(int front)
{
	front = (front + 1) % (N + 1);
	return front;

}

int main()
{
	int i;
	int Q[N + 1] = { 10, 20, 30, 40, 50 };
	int front, rear;
	int *s;
	s = (int *)malloc((N)*sizeof(int));
	front = 0;
	rear = 0;
	cout << "此时的front值为：" << front << ",rear的值为：" << rear << endl;
	for (i = 0; i<N + 1; i++)
	{
		//Q[i]入队
		if ((rear + 1) % (N + 1) == front)
		{
			printf("队已满,%d已出队\n", Q[front]);
			front = out(front);
			printf("此时的front和rear值为：%d,%d\n", front, rear);
		}
		rear = in(s, rear, Q[i]);
		printf("%d已入队\n", Q[i]);
		printf("此时的front和rear值为：%d,%d\n", front, rear);
	}
	//Q[i]出队
	while (front != rear)
	{
		front = out(front);
		printf("%d已出队\n", s[front]);
		printf("此时的front和rear值为：%d,%d\n", front, rear);
	}
	system("pause");
	return 0;
}

链队列的实现：

# include <iostream>
using namespace std;

typedef int ElemType;

typedef struct QNode
{
	ElemType data;
	QNode *next;

}QNode, *QueuePtr;      //节点

//单链队列
typedef struct
{
	QueuePtr front;     //队头指针
	QueuePtr rear;		//队尾指针
}LinkQueue;


class MyLinkQueue
{
public:
	void InitQueue();		//初始化队列
	void DestroyQueue();		//销毁队列
	void ClearQueue();		//清空队列
	bool QueueEmpty();		//队列是否为空
	int QueueLength();		//队列长度
	void Enqueue(ElemType val);	//在队尾插入数据
	void DeQueue(ElemType & val);	//删除队头
	void Print();			//从头到尾打印

private:
	LinkQueue q;
};

//初始化队列
void MyLinkQueue::InitQueue()
{
	q.front = q.rear = (QueuePtr)malloc(sizeof(QNode));
	if (!q.front)
	{
		//如果分配失败
		cout << "初始化失败" << endl;
		return;
	}
	q.front->next = NULL;
}

//销毁队列
void MyLinkQueue::DestroyQueue()
{
	while (q.front)
	{
		q.rear = q.front->next;
		free(q.front);
		q.front = q.rear;
	}
}
//在队尾插入数据
void MyLinkQueue::Enqueue(ElemType val)
{
	QueuePtr ptr = (QueuePtr)malloc(sizeof(QNode));
	if (!ptr)
	{
		//如果分配失败
		cout << "节点分配失败" << endl;
		return;
	}
	ptr->data = val;
	ptr->next = NULL;
	q.rear->next = ptr;
	q.rear = ptr;
}
//删除队头，并返回当前队头的值
void MyLinkQueue::DeQueue(ElemType & val)
{
	if (q.front == q.rear)
	{
		val = -1;
		return;
	}
	QueuePtr p;
	val = q.front->next->data;
	if (q.front->next == q.rear){//队列只有一个元素
		p = q.rear;
		q.rear = q.front;
		q.front->next = NULL;
	}
	else{
		p = q.front->next;
		q.front->next = p->next;
		p->next = NULL;
	}
	free(p);
}

//打印
void MyLinkQueue::Print()
{
	if (q.front == q.rear)
	{
		cout << "队列为空" << endl;
		return;
	}
	QueuePtr ptr = q.front->next;
	while (ptr != q.rear)
	{
		cout << ptr->data << endl;
		ptr = ptr->next;
	}
	cout << ptr->data << endl;
}

//清空队列
void MyLinkQueue::ClearQueue()
{
	DestroyQueue();
	InitQueue();
}


//队列是否为空
bool MyLinkQueue::QueueEmpty()
{
	if (q.front == q.rear)
		return true;
	else
		return false;
}
//队列长度
int MyLinkQueue::QueueLength()
{
	if (q.front == q.rear)
		return 0;
	QueuePtr ptr = q.front;
	int index = 0;
	do
	{
		index++;
		ptr = ptr->next;
	} while (ptr != q.rear);
	return index;
}

int main()
{
	MyLinkQueue q;
	bool flag = q.QueueEmpty();
	q.InitQueue();
	q.Enqueue(1);
	q.Enqueue(2);
	q.Enqueue(3);
	q.Enqueue(4);
	q.Enqueue(5);
	q.Enqueue(6);
	q.Enqueue(7);
	int len = q.QueueLength();
	q.Print();
	int val;
	q.DeQueue(val);
	q.DeQueue(val);
	cout << "取出两个队头后打印" << endl;
	q.Print();
	q.ClearQueue();
	q.Print();
	cout << "入队：" << endl;
	q.Enqueue(1);
	q.Enqueue(2);
	q.Enqueue(3);
	q.Enqueue(4);
	q.Print();
	system("pause");
	return 0;
}

2.2.2循环队列

           为了解决假溢出现象并使得队列空间得到充分利用，引出循环队列。

        循环队列是队列的一种顺序表示和实现方法：将顺序队列的数组看成是一个环状的空间，即规定最后一个单元的后继为第一个单元。如下图所示，队头指针始终指向当前的队头元素，而队尾指针始终指向真正队尾元素后面的单元。

借助于取模（求余）运算，可以自动实现队尾指针、队头指针的循环变化。

  • 进队操作时，队尾指针的变化是：rear=(rear+1) mod MAXSIZE；
  • 出队操作时，队头指针的变化是：front=(front+1) mod MAXSIZE.

循环队列“满”的条件为：（rear+1）mod MAXSIZE = front.

判队空的条件依旧是：rear=front.

循环队列的实现：

# include <iostream>
using namespace std;

#define MAX_QUEUE_SIZE 100
typedef int ElemType;

typedef struct QNode
{
	ElemType data;
	QNode *next;

}QNode, *QueuePtr;      //节点

//循环队列
typedef struct{
	ElemType *base;
	int front;
	int rear;
}SqQueue;

class CircularQueue
{
public:
	void InitQueue();			//初始化队列
	void DestroyQueue();		//销毁队列
	void ClearQueue();			//清空队列
	bool QueueEmpty();			//队列是否为空
	int QueueLength();			//队列长度
	void Enqueue(ElemType val);	//在队尾插入数据
	void DeQueue(ElemType & val);	//删除队头
	void Print();					//从头到尾打印

private:
	SqQueue q;
};

//初始化队列
void CircularQueue::InitQueue()
{
	q.base = (ElemType *)malloc(sizeof(ElemType)* MAX_QUEUE_SIZE);
	if (!q.base)
	{
		//如果分配失败
		cout << "初始化失败" << endl;
		return;
	}
	q.front = q.rear = 0;
}

//销毁队列
void CircularQueue::DestroyQueue()
{
	free(q.base);
	q.front = q.rear = 0;
}
//在队尾插入数据
void CircularQueue::Enqueue(ElemType val)
{
	if ((q.rear + 1) % MAX_QUEUE_SIZE == q.front)
	{
		cout << "队列已满！" << endl;
		return;
	}
	q.base[q.rear] = val;
	q.rear = (q.rear + 1) % MAX_QUEUE_SIZE;
	return;
}
//删除队头，并返回当前队头的值
void CircularQueue::DeQueue(ElemType & val)
{
	if (q.front == q.rear)
	{
		cout << "队列为空！" << endl;
		return;
	}
	val = q.base[q.front];
	q.front = (q.front + 1) % MAX_QUEUE_SIZE;
	return;
}

//打印
void CircularQueue::Print()
{
	if (q.front == q.rear)
	{
		cout << "队列为空" << endl;
		return;
	}
	for (int i = q.front; i < q.rear; i++)
		cout << q.base[i] << endl;
	return;
}

//清空队列
void CircularQueue::ClearQueue()
{
	DestroyQueue();
	InitQueue();
}


//队列是否为空
bool CircularQueue::QueueEmpty()
{
	if (q.front == q.rear)
		return true;
	else
		return false;
}
//队列长度
int CircularQueue::QueueLength()
{
	return (q.rear - q.front + MAX_QUEUE_SIZE) % MAX_QUEUE_SIZE;
}

int main()
{
	CircularQueue q;
	bool flag = q.QueueEmpty();
	q.InitQueue();
	q.Enqueue(1);
	q.Enqueue(2);
	q.Enqueue(3);
	q.Enqueue(4);
	q.Enqueue(5);
	q.Enqueue(6);
	q.Enqueue(7);
	int len = q.QueueLength();
	q.Print();
	int val;
	q.DeQueue(val);
	q.DeQueue(val);
	cout << "取出两个队头后打印" << endl;
	q.Print();
	q.ClearQueue();
	q.Print();
	cout << "入队：" << endl;
	q.Enqueue(1);
	q.Enqueue(2);
	q.Enqueue(3);
	q.Enqueue(4);
	q.Print();
	system("pause");
	return 0;
}

2.3队列的应用——约瑟夫环问题

#include<iostream>
using namespace std;

#define N 10
void JonesPlus(int Q[], int key)
{
	int front, rear;
	int i;
	front = 0;
	rear = N;
	while (front - rear)
	{
		for (i = 0; i<key - 1; i++)
		{
			front = (front + 1) % (N + 1);
			rear = (rear + 1) % (N + 1);
			Q[rear] = Q[front];
		}
		front = (front + 1) % (N + 1);
		printf("%d已出队\n", Q[front]);
	}
}

int main()
{
	int i;
	int Q[N + 1];
	for (i = 1; i<N + 1; i++)
		Q[i] = i;
	JonesPlus(Q, 3);
	system("pause");
	return 0;
}

「已注销」
关注
  • 7
    点赞
  • 踩
  • 39
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 栈与队列
yh的博客
03-31 348
1. 栈 栈是只能从一端访问的线性群体，是一种后进先出的数据结构。 栈示意图： 栈的基本状态： 栈空 栈满 一般状态 栈空：栈中没有元素（以数组容纳的栈为例） 栈满：栈中元素个数到达上限（以数组容纳的栈为例） ...
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构——6.栈
qq_51330164的博客
06-05 2711
6.栈 从数据结构角度看，栈和队列仍属于线性结构，具有线性结构的共同特征； 其个性是：栈和队列是操作受限的线性结构； 后进先出（LIFO，Last In First Out）或先进后出（FILO，First In Last Out）结构，最先（晚）到达栈的结点将最晚（先）被删除。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-bZmWipBl-1622898141212)(高数叔数据结构自学.assets/image-20210505012201242.png)] 栈顶（to
数据结构 栈（顺序栈，链式栈，用栈实现计算器）
海吹的技术博客
08-08 3004
一、栈的概念 1. 栈是一个特殊的线性表，只能在一端操作：栈顶（top）：允许操作 的一端                                                                     栈底（bottom）：不允许操作的一端 2. 特点：后进先出 二、顺序栈  1. 若存储栈的长度为StackSize，则栈顶位置top必须小于StackSiz...
C++ 数据结构和算法 - 简介
最新发布
一然明月(嵌入式)的博客
06-04 376
数据结构是计算机科学中的重要概念，它用于组织和存储数据，以便有效地进行数据操作和管理。主要内容:就是如何按一定的逻辑结构，把数据组织起来，并选择适当的存储表示方法把逻辑结构组织好的数据存储到计算机的存储器里。算法研究的目的是为了更有效的处理数据，提高数据运算效率。数据的运算是定义在数据的逻辑结构上，但运算的具体实现要在存储结构上进行.选择合适的数据结构取决于多种因素，包括数据的访问方式、操作的频率、数据的大小等。算法是解决特定问题的一系列步骤和规则。
C++栈和队列（详解+刷题）
IT OR 考公？
07-10 2163
顺序栈，链栈，顺序队列，链队列
c语言 initqueue头文件,void main(){ Queue Q;InitQueue(Q); char x='e';y='c'; EnQueue(Q,'r');EnQueue(Q,y); D...
weixin_36012215的博客
05-25 2898
满意答案brnxa1372015.10.11采纳率：51%等级：10已帮助：768人题目没有打全。如果是：void main( ){Queue Q; Init Queue (Q);Char x=’e’; y=’c’;EnQueue (Q,’h’); EnQueue (Q,’r’); EnQueue (Q, y);DeQueue (Q,x); EnQueue (Q,x);DeQueue (Q...
C++数据结构与算法之双缓存队列实现方法详解
08-29
C++数据结构与算法之双缓存队列实现方法详解 本文主要介绍了C++数据结构与算法之双缓存队列实现方法，结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项。 知识点一：双缓存队列的定义 双缓存队列是一...
数据结构与算法分析C++版答案
10-14
本书提供了数据结构与算法分析的答案，涵盖了数组、链表、栈、队列、二叉树、图形等多种数据结构，以及算法分析、时间复杂度分析等方面的知识。 数据结构是计算机科学中的一种重要概念，指的是计算机中存储、组织和...
数据结构与算法-实验3 栈和队列
11-19
在IT领域，数据结构与算法是编程的基础，它们直接影响到程序的效率和性能。本实验主要涉及两种常用的数据结构...通过实验，学生可以加深对栈和队列概念的理解，掌握其操作原理，并学习如何用C++来实现这些数据结构。
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队
06-04
数据结构与算法C++实现 循环顺序队列的初始化，求长度，入队，出队 适合大二初学数据结构与算法 程序有详细备注，可直接运行 顺序表
栈和队列的实现
12-17
用C++对栈和队列的详细实现，对初学者很有用
栈与队列经典例题详解
06-06
体育课经常排在上午3、4节，一节课下来大家都筋疲力尽、饥肠辘辘。将近下课，体育老师一吹口哨大家立即集合，不过这次集合大家都站成了一排，然后老师说向右看齐，这时每个人只能看到右侧比自己矮的人头，如果突然出现一个高于或等于自己身高的同学，那么这名同学以及其右侧的同学将会被挡住。那么，问题来了，现给定所有同学的身高（假设体育课大家修炼了一种神秘技能，改变了自己的身高，（身高最大值为2*106），要求每个人能往右侧看到的人数之和（建议使用long long存储）。
标志量循环队列初始化void initqueue(seqqueue Q).cpp
05-18
标志量循环队列初始化void initqueue(seqqueue Q).cpp
C语言 秒懂的队列操作
qq_41740162的博客
04-19 524
文章目录什么是队列队列定义常见的队列操作(C语言)``如果对你有所帮助,点个赞呗``队列的顺序存储结构结构体实现代码初始化入队出队获取队头元素全部代码文件结构Main函数头文件.C文件运行截图``换大家在评论区赐教,写写`` 什么是队列 通俗易懂的就是说一跟管道里的水流出来,里面的水分子就是一组队列先进先出(First In First Out)他和栈的操作类似,都是操作受限的的线性表 队列定义 ...
队列的创建以及基本操作
热门推荐
大芝士球的博客
02-15 1万+
队列(FIFO)是只允许在一段插入，另一端删除的线性表，遵循先进先出原则，队头删除，队尾插入。顺序队列使用用数组存储 初始条件 front =rear=0满队列：rear=m    容量m空队列:   front=rear 结构：typedef struct { int data[MAX]; int front,rear; }Queue;操作：/初始化队列 Queue InitQueue() ...
C++ 栈和队列
secretalive的博客
04-09 238
C++ 栈和队列
数据结构学习：队列
weixin_45632016的博客
07-27 244
数据结构学习：队列 栈（Stack）是只允许在一端进行插入或删除操作的线性表 队列（Queue）是只允许在一端进行插入，在另一端删除的线性表 队列的特点：先进先出 InitQueue(&Q)：初始化队列，构造一个空队列Q。 DestroyQueue(&Q)：销毁队列。销毁并释放队列Q所占用的内存空间。 EnQueue(&Q,x)：入队，若队列Q未满，将x加入，使之成为新的队尾。 DeQueue(&Q,&x)：出队，若队列Q非空，删除队头元素，并用x返回。 GetHe
C++栈和队列
一位小学生的博客
07-20 1187
C++栈和队列
C++数据结构与算法分析解题指南
"《数据结构与算法分析C++描述（答案）》是针对经典数据结构与算法分析课程的课后习题解答，旨在帮助学习者深入理解和掌握C++中的数据结构与算法。这本书由Greg Tobin等专业人士编辑，由Pearson Education, Inc.出版...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值