数据结构与算法_【3】栈和队列（C++实现）

最新推荐文章于 2022-07-15 15:25:47 发布
最新推荐文章于 2022-07-15 15:25:47 发布
阅读量661 收藏 6
点赞数
分类专栏： 数据结构与算法学习笔记 文章标签： 数据结构 算法 队列 链表 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40585997/article/details/119427567
版权

参考：数据结构与算法基础（青岛大学-王卓）
传送门：
数据结构与算法_【1】概念引入（C++实现）
数据结构与算法_【2】线性表（顺序表链表）（C++实现）
数据结构与算法_【3】栈和队列（C++实现）
数据结构与算法_【4】串数组广义表（C++实现）
数据结构与算法_【5】树和二叉树（C++实现）
数据结构与算法_【6】树和森林（C++实现）
数据结构与算法_【7】哈夫曼树（C++实现）
数据结构与算法_【8】图（C++实现）
数据结构与算法_【9】查找（C++实现）
数据结构与算法_【10】排序（C++实现）

栈和队列

栈（后入先出）和队列（先进先出）是限定插入和删除只能在表的“端点”的线性表

1 概念

1.1栈

栈是仅在表尾进行插入、删除操作的线性表；表尾称为栈顶Top，表头称为栈底Base；插入元素到栈顶（表尾）的操作称为入栈，从栈顶（表尾）删除最后一个元素的操作称为出栈。
逻辑结构：一对一关系，前驱后继
存储结构：顺序栈、链栈，顺序栈较为常见
运算规则：只能栈顶运算（与一般线性表的区别）

1.2队列

队列是一种先进先出的线性表，在表一端插入（表尾）,在另一端（表头）删除
逻辑结构：一对一，前驱后继
存储结构：顺序队或栈队，循环顺序队列较为常见
运算规则：先进先出，队首和队尾操作

2 实现

2.1 顺序栈的表示和实现

利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素，栈底一般在低地址端
附设top指针，指示栈顶元素在顺序栈中的位置，但是为了操作方便，通常top指示真正的栈顶元素之上的下标地址！
另设base指针，指示栈底元素在顺序栈中的位置
stacksize表示栈可以使用的最大容量
空栈：top == base
栈满：top - base = stacksize
栈满时处理方法：（1）报错，返回操作系统；（2）分配更大的空间，作为栈的存储空间，将原栈的内容移入新栈
溢出：（1）上溢，栈已经满,又要压入元素；（2）下溢，栈已经空，还要弹出元素
注：上溢是一种错误，使问题的处理无法进行，而下溢一般认为是一种结束条件，即问题处理结束

顺序栈实现：

template<typename T>
class SeqStack {
private:
	T* top;
	T* base;
	int stackSize;
public:
	SeqStack();
	bool StackEmpty();
	bool StackFull();
	void ClearStack();
	void DestroyStack();
	void ShowStack();
	void Push(const T& e);
	void Pop(T& e);
	//void StackFull();

	~SeqStack();
};

template<typename T>
SeqStack<T>::SeqStack()
{
	this->base = new T[MAXSIZE];
	if (!this->base)
	{
		cout << "分配地址失败！！！" << endl;
		return;
	}
	this->top = this->base;
	this->stackSize = MAXSIZE;
}
//后面实现 略

2.2 链栈的表示和实现

链栈是运算受限的单链表，只能在链表头部进行操作

在这里插入图片描述

说明：
链表的头指针就是栈项
不需要头结点
基本不存在栈满的现象
空栈相当于头指针指向空
插入和删除仅在栈顶处执行

2.3 栈与递归

递归定义：
（1）若一个对象部分地包含它自己，或用它自己给自己定义，则称这个对象是递归的
（2）若一个过程直接地或间接地调用自己，则称这个过程是递归的过程
嵌套调用执行过程：
（遵循后调用先返回，与栈后入先出相似）

在这里插入图片描述

递归优缺点
优点：结构清晰，程序易读
缺点：每次调用要生成工作记录，保存状态信息，入栈；返回时要出栈，恢复状态信息。时间开销大

递归->非递归
（1）尾递归、单向递归->循环结构
（2）自用 栈 模拟系统的运行时栈

2.4 顺序队列的表示和实现

队列（Queue）仅在表尾进行插入操作，在表头进行删除操作的线性表；是一种先进先出（FIFO）的线性表；插入元素称作入队，删除元素称作出队；队列的存储结构为链队或顺序队（常用循环顺序队）
逻辑结构：与同性线性表一致，仍为一对一关系
存储结构：链队或顺序队（常用循环顺序队）
运算规则： 只能在队尾和队首运算，先进先出
实现方式：关键掌握入队出队

创建队列：

template<typename T>
class SeqQueue {
private:
	T* base;//初始化动态分配的存储空间
	int front;//头指针
	int rear;//尾指针

};

在这里插入图片描述

解决假上溢的方法：引入循环队列

队空队满时都有：front == rear
解决方法：（1）另外设一个标志以区别队空队满；（2）另外设一个变量，记录元素个数；（3）少用一个元素空间

(rear+1)%MAXQSIZE == front;

2.5 链式队列的表示和实现

若用户无法估计所用队列的长度，则宜采用链队！

在这里插入图片描述

3 代码实现

3.1 顺序栈（seqStack）代码实现

#pragma once
#include<iostream>
using namespace std;

#define MAXSIZE 100

template<typename T>
class SeqStack {
private:
	T* top;
	T* base;
	int stackSize;
public:
	SeqStack();
	bool StackEmpty();
	bool StackFull();
	void ClearStack();
	void DestroyStack();
	void ShowStack();
	void Push(const T& e);
	void Pop(T& e);
	//void StackFull();

	~SeqStack();
};

template<typename T>
SeqStack<T>::SeqStack()
{
	this->base = new T[MAXSIZE];
	if (!this->base)
	{
		cout << "分配地址失败！！！" << endl;
		return;
	}
	this->top = this->base;
	this->stackSize = MAXSIZE;
}


template<typename T>
bool SeqStack<T>::StackEmpty()
{
	if (this->base == this->top)
	{
		cout << "栈为空！" << endl;
		return true;
	}
	return false;
}

template<typename T>
bool SeqStack<T>::StackFull()
{
	if ((this->top - this->base) == this->stackSize)
	{
		cout << "栈已满！" << endl;
		return true;
	}
	return false;
}

template<typename T>
void SeqStack<T>::ClearStack()
{
	if (this->base)
	{
		this->top = this->base;
		cout << "ClearStack！" << endl;
		return;
	}
	cout << "栈不存在，无法清空！" << endl;

}

template<typename T>
void SeqStack<T>::DestroyStack()
{
	if (this->base)
	{
		delete this->base;
		this->stackSize = 0;
		this->base = NULL;
		this->top = NULL;
		cout << "DestroyStack!" << endl;
		return;
	}
	cout << "栈不存在，无法销毁！" << endl;

}

template<typename T>
void SeqStack<T>::ShowStack()
{
	if (this->StackEmpty())
	{
		cout << "栈为空，无法打印！" << endl;
		return;
	}
	T* p = this->base;
	while (p != this->top)
	{
		cout << *p++ << endl;
	}

}


template<typename T>
void SeqStack<T>::Push(const T& e)
{
	if (this->StackFull())
	{
		cout << "栈已满！无法入栈！" << endl;
		return;
	}
	*this->top ++ = e;

}

template<typename T>
void SeqStack<T>::Pop(T& e)
{
	if (this->StackEmpty())
	{
		cout << "栈为空！无法出栈！" << endl;
		return;
	}
	e = *--this->top;//注意这里this->top指向为空，要先-1，再弹出 不能打印top指针指向的元素！！！
}




template<typename T>
SeqStack<T>::~SeqStack()
{

}

3.2 链栈（linkStack）代码实现

#pragma once
#include<iostream>
using namespace std;


template<typename T>
class LinkStack;

//注意这里结点的定义，不能与链表里的类名重复！
template<typename T>
class LinkNode_Stack {
	friend class LinkStack<T>;
public:
	LinkNode_Stack()
	{
		//this->m_data = 0;
		this->next = NULL;
	}
	~LinkNode_Stack()
	{

	}
private:
	T m_data;
    //嵌套定义：自己定义自己
	LinkNode_Stack<T>* next;
};

template<typename T>
class LinkStack {

private:
	LinkNode_Stack<T>* head;
public:
	LinkStack();
	bool StackEmpty();
	void ShowLinkStack();
	void Push(const T& e);//将e压入栈
	void Pop(T& e);// 出栈,通过e返回
	//void PopPtr(T* e);//出栈，返回指针 ！！！未检测！！！

	~LinkStack();



};

template<typename T>
LinkStack<T>::LinkStack()
{
	this->head = new LinkNode_Stack<T>;
}

template<typename T>
bool LinkStack<T>::StackEmpty()
{
	if (this->head->next == NULL)
	{
		//cout << "栈为空！" << endl;
		return true;
	}
	return false;

}

template<typename T>
void LinkStack<T>::ShowLinkStack()
{
	if (this->StackEmpty())
	{
		cout << "链栈为空！无法打印！" << endl;
		return;
	}
	LinkNode_Stack<T>* p = this->head;
	while (p->next)
	{
		cout << p->m_data << endl;
		p = p->next;
	}

}


template<typename T>
void LinkStack<T>::Push(const T& e)
{
	LinkNode_Stack<T> *p = new LinkNode_Stack<T>;//分配一个结点地址
	p->m_data = e;
	p->next = this->head;
	this->head = p;

}

template<typename T>
void LinkStack<T>::Pop(T& e)
{
	if (this->StackEmpty())
	{
		cout << "链栈为空！无法出栈！" << endl;
		return;
	}

	e = this->head->m_data;
	LinkNode_Stack<T>* p = this->head;
	this->head = this->head->next;
	delete p;//从栈中释放数据

}

//template<typename T>
//void LinkStack<T>::PopPtr(T* e)
//{
//	if (this->StackEmpty())
//	{
//		cout << "链栈为空！无法出栈！" << endl;
//		return;
//	}
//
//	e = this->head
//	LinkNode_Stack<T>* p = this->head;
//	this->head = this->head->next;
//	delete p;//从栈中释放数据
//}


template<typename T>
LinkStack<T>::~LinkStack()
{

}

3.3 顺序队（seqQueue）代码实现

#pragma once
#include<iostream>
using namespace std;

#define MAXQSIZE 5

template<typename T>
class SeqQueue {
private:
	T* base;//初始化动态分配的存储空间
	int front;//头指针
	int rear;//尾指针

public:
	SeqQueue();
	int QueueLenth();
	void ShowQueue();
	void EnQueue(const T& e);//将e填入队列(队尾插入)
	void DeQueue(T& e);//删除元素，通过e返回（队尾删除）
	
	~SeqQueue();


};

template<typename T>
SeqQueue<T>::SeqQueue()
{
	this->base = new T[MAXQSIZE];
	if (!this->base)
	{
		cout << "内存分配失败！" << endl;
		return;
	}
	this->front = 0;
	this->rear = 0;
}

template<typename T>
int SeqQueue<T>::QueueLenth()
{
	//循环队列！ rear不一定在front后面，也有可能在前面的地址！
	return (this->rear - this->front + MAXQSIZE) % MAXQSIZE;
}
 
template<typename T>
void SeqQueue<T>::ShowQueue()
{
	if (this->front == this->rear)
	{
		cout << "队列为空！无法打印！" << endl;
		return;
	}

	int lenth = this->QueueLenth();
	int i = this->front;
	while (lenth)
	{
		cout << this->base[i] << endl;
		i = (i + 1) % MAXQSIZE;
		lenth--;
	}

}


template<typename T>
void SeqQueue<T>::EnQueue(const T& e)
{
	//避免出现队空队满时都有：front == rear
	//只允许插入MAXQSIZE-1个元素
	if ((this->rear + 1) % MAXQSIZE == this->front)
	{
		cout << "队列已满！无法插入！" << endl;
		return;
	}
	this->base[this->rear] = e;
	this->rear = (this->rear + 1) % MAXQSIZE;

}

template<typename T>
void SeqQueue<T>::DeQueue(T& e)
{
	if (this->front == this->rear)
	{
		cout << "队列为空！无法删除！" << endl;
	}
	e = this->base[this->front];
	this->front = (this->front + 1) % MAXQSIZE;

}

template<typename T>
SeqQueue<T>::~SeqQueue()
{

}

3.4 链队（linkQueue）代码实现

#pragma once
#include<iostream>
using namespace std;

#define MAXLQSIZE 100;

template<typename T>
class LinkQueue;

template<typename T>
class LinkNode_Queue {
	friend class LinkQueue<T>;
private:
	T m_data;
	LinkNode_Queue* next;
public:
	LinkNode_Queue()
	{
		this->m_data = 0;
		this->next = NULL;
	}
	~LinkNode_Queue()
	{

	}

};

template<typename T>
class LinkQueue {
private:
	LinkNode_Queue<T>* front;
	LinkNode_Queue<T>* rear;
public:
	LinkQueue();
	void DestroyQueue();
	void ShowQueue();
	void EnQueue(const T& e);//将e入队
	void DeQueue(T& e);//队头出队，通过e返回
	~LinkQueue();

};

template<typename T>
LinkQueue<T>::LinkQueue()
{
	this->front = new LinkNode_Queue<T>;
	if (!this->front)
	{
		cout << "内存分配失败！" << endl;
		return;
	}
	this->rear = this->front;
}


template<typename T>
void LinkQueue<T>::DestroyQueue()
{
	while (this->front)
	{
		LinkNode_Queue<T>* p = this->front->next;
		delete this->front;
		this->front = p;
	}

}

template<typename T>
void LinkQueue<T>::ShowQueue()
{
	if (this->front == this->rear)
	{
		cout << "队列为空！无法打印" << endl;
		return;
	}
	//注意这里存在头结点
	LinkNode_Queue<T> *p = this->front->next;//指针p指向首元结点
	while (p)
	{
		cout << p->m_data << endl;
		p = p->next;

	}
}

template<typename T>
void LinkQueue<T>::EnQueue(const T& e)
{
	LinkNode_Queue<T> *p = new LinkNode_Queue<T>;
	p->m_data = e;
	this->rear->next = p;
	this->rear = this->rear->next;

}

template<typename T>
void LinkQueue<T>::DeQueue(T& e)
{
	if (!this->front)
	{
		cout << "队列为空！无法出队！" << endl;
		return;
	}
	e = this->front->next->m_data;
	LinkNode_Queue<T>* p = this->front->next;
	this->front->next = this->front->next->next;
	if (this->rear == p)
	{
		this->rear = this->front;
	}
	delete p;

}


template<typename T>
LinkQueue<T>::~LinkQueue()
{

}
gXh_007
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核show_stack,Linux内核kpatch快速参考
weixin_31040783的博客
05-02 1099
1kpatch介绍1.1kpatch概览kpatch 是一个动态的内核补丁技术, 它可以直接让你对一个正在运行的内核打补丁而不需要进行系统重启. 对于系统管理员来说,他/她可以更从容安排系统维护计划.1.2kpatch是如何工作的.kpatch 通过内核的ftrace机制,对被打补丁的内核函数进行重定向;当被打补丁的函数被调用时,通过函数代码段预留的钩子,进而重定向到补丁函数,执行完毕后,再返回初...
C++单链表简单实现栈和队列(继承和派生)
星辰大海的博客
04-04 2778
先上题目： 设计单链表类，并基于单链表类实现栈类和队列类： （1）设计学生信息类StudentRecord，要求包含公有数据成员：string stuName和int stuNo，设计用于输出学生信息的公有成员函数：void print()，输出格式为：Name: stuName, Number: stuNo。 （2）设计学生链表的结点类StudentNode，要求包含公有数据成员：Student...
面向对象程序设计C++——利用链表实现栈和队列（继承）
ChristensonLee的博客
05-08 1710
**【问题描述】**利用链表实现栈和队列 队列具有先进先出的特点，所有新来的元素都放在队列尾部，出队列的元素从队列头部出去。下面是队列的示意图： 栈具有后进先出的特点。所有入栈的元素都放在栈顶，出栈时栈顶元素先出。下面是栈的示意图： 这两种结构具有很多相似的地方：都存放了一系列的元素，元素的操作都在两头进行，元素个数都是动态可变的。我们可以设计一个基类，完成它们共同的功能，然后分别派生出队列类和栈类。本实验要求以上一个实验实现的链表类作为基类并设计它的两个派生类。 要求： (1) 在上一个实验实现的链表
数据结构和算法学习之路——栈和队列详解(C++版)
凝望，划过星空的博客
05-26 701
数据结构和算法学习之路——栈和队列详解(C++) 文章目录数据结构和算法学习之路——栈和队列详解(C++)(一) 栈1.1 栈的工作原理 (一) 栈 1.1 栈的工作原理 栈是一种后进先出的线性表，什么是后进先出呢？我们可以举一个例子形象的理解，比如我们有一个桶，一次只能放进一个物体，那么很显然，我们第一次放进去的东西被压在了桶底，如果这个桶每层都有东西的话，我们是无法第一次就把最底下(也就是最早...
C++:栈与队列
RNGWGzZs的博客
07-15 760
1)栈与队列的功能---------------"你不会因为懒惰而悔恨"(1)栈与队列的功能①实现关于STL库中，栈和队列的功能和当初用C实现栈和队列的功能相似。其中，最值得注意的，就是红色标记处------容器。我们知道，不管是栈、队列它的底层，既可以用顺序表、也可以用链表来实现。同一类型，不同容器。②访问不同于list\vector,它们拥有自己的迭代器，支持访问。队列和栈都不支持随机访问。我们知道，栈的原则是FILO(先进后出，后进先出)。下面是测试。...
数据结构与算法基础课程 C语言C++程序语言设计教程 3_1栈和队列 共29页.pptx
最新发布
07-20
3_1栈和队列 共29页.pptx 3_2递归和非递归 共22页.pptx 4_1串 共18页.pptx 5_1 数组 共19页.pptx 6_1二叉树 共19页.pptx 6_2森林和哈夫曼树 共15页.pptx 7_1 图（存储、遍历、连通） 共49页.pptx 7_2图（拓扑排序、...
数据结构算法集---C++语言实现.rar_queue stack_堆栈 栈_数据结构 队列_链表_队列
07-15
在这个C++实现的数据结构算法集中，主要涉及了几个核心概念：队列、堆栈和链表，这些都是数据组织和操作的基本工具。 首先，让我们来看看堆栈（Stack）。堆栈是一种后进先出（LIFO）的数据结构，它的操作类似于日常...
数据结构和算法_数据结构_C++中的数据结构和算法_
10-01
C++作为一种强大的编程语言，提供了丰富的工具来实现各种数据结构和算法。本资源聚焦于C++中的数据结构和算法，旨在帮助您深入掌握这些核心概念。 数据结构是组织和存储数据的方式，它决定了数据的访问效率和操作...
C++数据结构与算法之双缓存队列实现方法详解
08-29
C++数据结构与算法之双缓存队列实现方法详解 本文主要介绍了C++数据结构与算法之双缓存队列实现方法，结合实例形式分析了双缓存队列的原理、实现方法与相关注意事项。 知识点一：双缓存队列的定义 双缓存队列是一...
队列实现栈_栈_数据结构_队列_
09-30
本篇将重点讨论如何利用队列来实现栈的功能，以及这两种数据结构在实际问题中的应用。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，它的主要操作包括压入（push）元素到栈顶和弹出（pop）栈顶元素。在...
栈和队列C++源代码
11-24
数据结构中栈和队列的源代码，C++实现，基于类。
C++数据结构实验---栈和队列【多项式计算】
海到无边天作岸 山登绝顶我为峰
10-22 2871
实验二 栈和队列 1.实验内容与要求 理解栈和队列的逻辑结构及应用场景 针对实际问题选择循环队列或链栈的方法，编程实现构造、插入、删除等基本操作 掌握栈和队列的存储原理 2.实验环境 硬件环境：计算机 软件环境:vc++ 3.实验算法伪代码 计算优先级： char Priority(char ch1,char ch2){ int a; int b; switch(ch1){ case '=' : a=0; break; case '(' : a= 1; break;
数据结构之C++实现栈与队列的建立及插入删除操作
清风
08-29 813
数据结构之C++实现栈与队列的建立及插入删除操作 栈的顺序存储结构 #include <iostream> using namespace std; #define MAXSIZE 50 class SqStack { public: SqStack(); //~SqStack(); void Push(int x);//在栈顶插入元素x void Pop(void);//删除栈顶元素 void show(void); private: int d
C++队列和栈用法详解
Little_Bro的博客
08-15 1251
目录基本理论容器deque队列queuepriority_queue栈stack参考资料 基本理论 首先最基本的是，队列是FIFO（先进先出）的，栈是FILO(先进后出)的。 很重要的一点是，在STL中往往都不把队列和栈归类为容器，而是归类为container adapter（容器适配器）。因此队列和栈的底部实现可以是deque、vector、list，而在我们常用的SGI STL中，两者均以容器deque为缺省情况下的底部结构。 // 使用vector为底层容器的栈的初始化 std::stack<i
栈和队列及其C++实现（一）
Kiritoku的博客
10-29 2383
栈的结构及其c++实现
3.7.1 运行时栈
xiaohaopei的博客
09-04 1675
C语言过程调用机制的一个关键特性（大多数其他语言也是如此）在于使用了栈数据结构提供的后进先出的内存管理原则。在过程P调用过程Q的例子中，可以看到当Q在执行时，P以及所有在向上追溯到P的调用链中的过程，都是暂时被挂起的。当Q运行时，他只需要为局部变量分配新的存储空间，或者设置到另一个过程的调用。另一方面，当Q返回时，任何它所分配的布局变量存储空间都可以被释放。因此，程序可以用栈来管理它的过程所需要的...
TCP/IP堆栈内存已用完，常见的处理方法
Paul SH
09-27 1434
1.重启notes或计算机。2.重置TCP/IP协议，操作如下：可以使用 NetShell 实用程序重置 TCP/IP 堆栈，使其恢复到初次安装操作系统时的状态。具体操作如下： 1、单击 开始 --&gt; 运行，输入 "CMD" 后单击 "确定"; 2、在命令行模式输入命令 netsh int ip reset C:\resetlog.txt (其中，Resetlog.txt记录命令结果的日志文...
栈空间为什么会满？
jackJruit的博客
04-08 2021
一、第一种解释 栈空间是预设的，它通常用于存放临时变量，如果你在函数内部定义一个局部变量，空间超出了设置的栈空间大小，就会溢出。 不仅如此，如果函数嵌套太多，也会发生栈溢出，因为函数没有结束前，函数占用的变量也不被释放，占用了栈空间。 二、第二种解释 对每个程序来说，栈能使用的内存是有限的，一般是 1M~8M，这在编译时就已经决定了，程序运行期间不能再改变。如果程序使用的栈内存超出最大值，就会发生栈溢出（Stack Overflow）错误，程序就崩溃了。 这个就像木桶里的水，木桶的容量有限，水满了自然会溢出
数据结构与算法解析：链表、栈、队列与二叉树
"该资源是一本由艾孜尔江编写的《数据结构算法大全》，主要针对面试中的数据结构和算法问题进行讲解，涵盖单链表、栈和队列、二叉树等多个主题，旨在帮助读者理解和掌握数据结构与算法的基础知识，提升面试竞争力。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值