栈和队列

最新推荐文章于 2022-05-17 16:37:49 发布
最新推荐文章于 2022-05-17 16:37:49 发布
阅读量233 收藏
点赞数 1
分类专栏： DS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/PNUHC/article/details/90550023
版权

栈和队列

  1. 什么是栈，栈有什么特性？
  2. 用C语言实现一个动态栈
  3. 栈和程序运行时的栈区有什么区别？
  4. 为什么将递归程序转化成循环时需要用到栈？
  5. 什么是队列，队列有什么特性？栈和队列有什么区别？
  6. 用C语言实现一个队列
  1. 什么是栈，栈有什么特性？

栈：一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。
压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈：栈的删除操作叫做出栈。出操作也在栈顶。
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一点。因为数组在尾上插入数据的代价比较小。

  1. 用C语言实现一个动态栈

Stack.h

#include<stdio.h>
#include<assert.h>
#include<malloc.h>

typedef int SDataType;
typedef struct Stack
{
	SDataType* _array;
	int _size;
	int _capacity;
}Stack;

void StackInit(Stack* ps);
void StackPush(Stack* ps, SDataType data);
void StackPop(Stack* ps);
SDataType StackTop(Stack* ps);
int StackSize(Stack* ps);
int StackEmpty(Stack* ps);
void StackDestroy(Stack* ps);

Stack.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Stack.h"

void CheckCapacity(Stack* ps)
{
	assert(ps);
	int NewCapacity = ps->_capacity * 2;
	if (ps->_size == ps->_capacity)
	{
		//开辟新空间
		SDataType* ptmp = (SDataType*)malloc(sizeof(SDataType)* NewCapacity);
		if (NULL == ptmp)
		{
			assert(0);
			return;
		}
		//拷贝元素到新开辟数组空间
		for (int i = 0; i < ps->_size; ++i)
			ptmp[i] = ps->_array[i];
		//释放旧数组
		free(ps->_array);
		ps->_array = ptmp;又得把ptmp（新数组）放进栈
		ps->_capacity = NewCapacity;//size不用管
	}
}
void StackInit(Stack* ps)
{
	assert(ps);
	ps->_array = (SDataType*)malloc(sizeof(SDataType)* 10);//注意左值是要初始化的栈中的数组
										初始化也要开辟新空间，开始给定一个最初开辟空间的大小capacity的值
	if (NULL == ps->_array)
	{
		assert(0);
		return;
	}
	ps->_capacity = 10;
	ps->_size = 0;
}
void StackPush(Stack* ps, SDataType data)
{
	assert(ps);
	//忽略之处
	CheckCapacity(ps);//插入新元素必须判断原来空间是否够用
	ps->_array[ps->_size] = data;
	ps->_size++;
}
void StackPop(Stack* ps)
{
	assert(ps);
	//if (NULL == ps->_array)//还是那句话，（尾）删除就需要先判空
	if(0 == ps->_size)  //这两个一样吗？？？ 不一样，size = 0；说明数组空间开辟成功，只是里面无元素
								//而 NULL == ps->_array	 则是数组未开辟成功空间，在初始化时即中止				
		return;
	ps->_size--;//怎么有点儿奇怪？也不用释放？只需要size--就ok？是的
}
SDataType StackTop(Stack* ps)//栈顶top 其实就是size（size是有效元素个数）只不过在栈的数组中下标是size-1
{
	assert(ps);
	return ps->_array[ps->_size - 1];
}
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->_size;
}
int StackEmpty(Stack* ps)
{
	assert(ps);
	return 0 == ps->_size;//空栈是capacity还是size？
}
void StackDestroy(Stack* ps)
{
	assert(ps);
	if (NULL == ps->_array)//重要理解
	{
		return;
	}
	free(ps->_array);
	ps->_capacity = 0;//capacity都为0了还需要size为0？
	ps->_size = 0;//这里两个都需要处理（销毁的时候，capacity = 0；size = 0（容易忘，注意））
}

void TestStack()
{
	Stack s;
	StackInit(&s);

	StackPush(&s, 1);
	StackPush(&s, 2);
	StackPush(&s, 3);
	printf("size = %d\n", StackSize(&s));
	printf("top = %d\n", StackTop(&s));

	StackPush(&s, 4);
	StackPush(&s, 5);
	printf("size = %d\n", StackSize(&s));
	printf("top = %d\n", StackTop(&s));

	StackPop(&s);
	StackPop(&s);
	printf("size = %d\n", StackSize(&s));
	printf("top = %d\n", StackTop(&s));

	StackDestroy(&s);
}
int main()
{
	TestStack();
	return 0;
}
  1. 栈和程序运行时的栈区有什么区别？

栈区：是一块内存空间，由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等
栈：具有后进先出的数据结构

  1. 为什么将递归程序转化成循环时需要用到栈？

在实现函数调用的时候，系统底层就是用栈来保存函数运行现场的；具体来说，每次调用函数时，会把当前函数的局部变量和返回地址都压栈保存起来，当函数调用结束返回的时候，再把局部变量从栈里弹出来。
而递归的核心就是重复的函数调用。因此如果要变成非递归，就可能需要自己实现栈数据结构用来保存一些状态变量；这其实就是在模拟函数调用。

  1. 什么是队列，队列有什么特性？栈和队列有什么区别？

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出FIFO(First In First Out)
入队列：进行插入操作的一端称为队尾
出队列：进行删除操作的一端称为对头
队列也可以数组和链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列在数组头上出数据，效率会比较低。
栈与队列的相同点：
1.都是线性结构。
2.插入操作都是限定在表尾进行。
3.都可以通过顺序结构和链式结构实现。、
4.插入与删除的时间复杂度都是O（1），在空间复杂度上两者也一样。
5.多链栈和多链队列的管理模式可以相同。
栈与队列的不同点：
1.删除数据元素的位置不同，栈的删除操作在表尾进行，队列的删除操作在表头进行。
2.应用场景不同；常见栈的应用场景包括括号问题的求解，表达式的转换和求值，函数调用和递归实现，深度优先搜索遍历等；常见的队列的应用场景包括计算机系统中各种资源的管理，消息缓冲器的管理和广度优先搜索遍历等。
3.顺序栈能够实现多栈空间共享，而顺序队列不能。

  1. 用C语言实现一个队列
    Queue.h
#include<stdio.h>
#include<assert.h>
#include<malloc.h>
#include<stdlib.h>
typedef int QDataType;
typedef struct QNode
{
	QDataType _data;
	struct QNode* _pNext;
}QNode,*pQNode;
typedef struct Queue
{
	pQNode _front;
	pQNode _back;
}Queue;

void QueueInit(Queue* q);
void QueuePush(Queue* q, QDataType data);
void QueuePop(Queue* q);
QDataType QueueFront(Queue* q);
QDataType QueueBack(Queue* q);
int QueueSize(Queue* q);
int QueueEmpty(Queue* q);
void QueueDestroy(Queue* q);
//void TestQueue();

Queue.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"Queue.h"

pQNode BuyNewNode(QDataType data)//注意参数和队列无关，别再传错了,还有QDataType data的QDataType别再忘记了
{
	pQNode pNewNode = (pQNode)malloc(sizeof(QNode));
	if (NULL == pNewNode)
	{
		assert(0);
		return NULL;
	}
	pNewNode->_data = data;
	pNewNode->_pNext = NULL;//不管data? 不行，在哪里？
	return pNewNode;
}
void QueueInit(Queue* q)
{
	assert(q);//对比栈（顺序表），这里初始化不需要开辟新空间（给第一个节点）
	q->_front = q->_back = NULL;//不管data，在这里，初始化不需要管data
}
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	pQNode pNewNode = BuyNewNode(data);
	if (NULL == q->_front)//插入需要判空,用头和尾随便一个判断？是的，但最后用头
	{
		q->_front = q->_back = pNewNode;//因为为空，所以不需要pNext
	}
	q->_back->_pNext = pNewNode;//连接
	q->_back = pNewNode;//队列尾往后走一个（也可以理解为标记）
}
void QueuePop(Queue* q)//插入：两种情况（1.判空 2.普通）
					   //删除：三种情况（1.判空 2.判断是都只有一个节点 3.普通）
{
	//assert(q);
	pQNode pDelNode = NULL;//用来标记头节点
	if (NULL == q->_front)
	{
		return;
	}
	//pDelNode = q->_front; //标记头节点（老师是在这里标记的）
	//if (NULL == pDelNode->_pNext)//判断是否只有一个节点（老师）
	if (q->_front == q->_back)//判断是否只有一个节点（我）
	{
		q->_front = q->_back = NULL;//是不是这样？是的
		free(q->_front);//这个在前面？必须在后面（理解），提前释放指针会丢失
		/只要删除就需要free
		//free(pDelNode);
	}
	else
	{
		pDelNode = q->_front; //标记头节点
		q->_front = q->_front->_pNext;
		free(pDelNode);//注意一下
		//pDelNode = NULL;//不需要
	}
	
}
QDataType QueueFront(Queue* q)
{
	assert(q);
	return q->_front->_data;
}
QDataType QueueBack(Queue* q)
{
	assert(q);
	return q->_back->_data;
}
int QueueSize(Queue* q)
{
	int count = 0;
	pQNode pCur = NULL;
	pCur = q->_front;
	while (pCur)
	{
		++count;
		pCur = pCur->_pNext;
	}
	return count;
}
int QueueEmpty(Queue* q)
{
	assert(q);
	return NULL == q->_front;//判空就是判断是否是初始化状态
}
void QueueDestroy(Queue* q)//需不需要判空
{
	assert(q);
	pQNode pCur = NULL;
	pCur = q->_front;
	if (NULL == q->_front)
		return;
	if (q->_front == q->_back)
		q->_front = q->_back = NULL;
	while (pCur)
	{
		q->_front = q->_front->_pNext;
		free(pCur);
		pCur = q->_front;
	}
	//循环结束还有一步（让队列尾back指向空），别再忘记了
	q->_front = q->_back = NULL;//（对比单链表无这一步？！）多余吗？
								//不多余，这一步目的在于让 q->_back = NULL;
	//队列和单链表区别在于 队列还有个队尾指针，千万别忘记处理
}
void TestQueue()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	QueuePop(&q);
	printf("front = %d\n", QueueFront(&q));
	printf("back = %d\n", QueueBack(&q));
	printf("size = %d\n", QueueSize(&q));

	QueuePop(&q);
	printf("size = %d\n", QueueSize(&q));
	QueueDestroy(&q);
}
int main()
{
	TestQueue();
	system("pause");
	return 0;
}
PHONER'S NUHC
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环内部局部变量与调用栈
weixin_41968820的博客
01-14 733
正如其他博客所提到的，局部变量的生命周期是在一个大括号内，即一个所处块结束。 局部变量和全局变量的区别，局部变量的生命周期是从创建开始到所处的块结束就被回收，而全局变量的生命周期是从创建开始到程序结束。 正如上面所说，局部变量是直到所处的块结束才从调用栈中把它回收。先看下面的代码。 for(int i = 0;i&amp;lt;10;i++) { int j=0; } 上面代码中的的整型变量i知道for循...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
栈、递归、循环的关系
热门推荐
_ACME_的博客
01-31 1万+
栈和递归其实原理都是差不多的，栈是先进后出，递归也是先进后出，递归也是利用堆栈来实现的，然后循环可以模拟代替栈和递归，只是用循环太复杂。但是它们的变量存储方式不同，导致占的空间不同。首先说明一下栈和堆的不同（这里的栈是系统自动维护的一种数据结构，内存分配方式和我们自己写的栈数据结构是不一样的。）。栈：就是那些由编译器在需要的时候分配，在不需要的时候自动清除的变量的存储区。里面的变量通常是局部变量、函
栈区中越界可能造成的死循环可能
游辞的博客
05-17 222
栈区中越界可能造成的死循环可能
Linux 栈中数组访问越界导致死循环现象
qq_29296283的博客
05-10 381
1.引言 最近在学习极客时间课程过程中碰到个挺有意思的关于数组和Linux 栈中增长方向的问题，特来与大家分享下。 话不多说，先上代码 int main(int argc, char* argv[]){ int i = 0; int arr[3] = {0}; for(; i<=3; i++){ arr[i] = 0; printf("hello world\n"); } return 0; } 代码很简单。当使用gc
递归与循环、栈
diaoju3333的博客
11-15 208
递归与循环的共同点：同一计算被执行多次； 递归与栈的共同点：递归依靠栈帧来存储先进后出的计算，栈存储先进后出的数据；共同点是存储。 或者可以这么理解：递归解决的是有依赖顺序关系的多个问题。 递归与栈的关系 因为程序中的栈结构是顺序栈，因此，如果递归的次数过多，程序中的数据过大，在不断的压栈过程中造成栈空间耗尽而产生栈溢出。 递归可以使用栈转化为循环。 ...
数据结构栈和队列
04-08
栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
Python实现栈和队列的简单操作方法示例
09-18
主要介绍了Python实现栈和队列的简单操作方法,结合实例形式详细分析了Python栈和队列的原理与简单实现技巧,需要的朋友可以参考下
栈和队列PPT
05-23
栈和队列PPT课件，想要了解栈和队列的同学，可以下载一下。
循环和递归对内存的消耗
qq_55910177的博客
04-12 2360
在日常开发场景中，在处理一些业务和问题时，经常会使用for循环或者递归，但在这两个方式中却会引发令人意外的问题
数据结构 栈与队列(循环队列) 数组实现
星光不问赶路人的博客
08-14 124
栈与队列栈队列 栈 栈是满足后进先出的一种数据结构，我这里是rear指针指向的栈顶不空的地方 #include <iostream> #include <cstring> using namespace std; const int N = 10010; int stk[N], rear; void menu(); void init(); void destoryStack(); void clearStack(); bool stackEmpty(); int stack
详细讲解栈的使用方法
galaxyrt的博客
05-23 2482
栈的使用方法详细讲解 栈：是后进先出的线性表，表尾对栈有特殊的含义，称为栈顶（top）相应的，表头成为栈底（bottom）不含元素的空表称为空栈 栈定义在<stack>头文件中 下面是栈类成员函数原型： //----容量capacity---- bool empty(); //测试是否为空栈 size_type size(); //返回栈的长度 //----元素存取element access----- top(); //返回栈顶元素 //----栈运算operators-----
c语言创建一个循环栈,c语言创建栈,压栈,出栈,遍历栈,清空.doc
weixin_30418751的博客
05-22 501
//创建堆栈，压栈，出栈，遍历栈，清空栈 2012.7.20#include#include#includevoid init_stack(struct stack *ps);//初始化void push(struct stack *ps); //压栈void pop(struct stack *ps); //出栈void clear_stack(stru...
android手机应用源码Imsdroid语音视频通话源码.rar
最新发布
05-20
android手机应用源码Imsdroid语音视频通话源码.rar
数据结构栈和队列实验
10-08
数据结构中的栈和队列是两种重要的数据结构。栈（Stack）是一种具有特殊限制的线性数据结构，它遵循LIFO（后进先出）原则，即最后进入的元素首先被访问或删除。栈有两个基本操作：压入（push）和弹出（pop）。队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值