数据结构 栈和队列

最新推荐文章于 2024-10-31 21:04:10 发布
最新推荐文章于 2024-10-31 21:04:10 发布
阅读量162 收藏 1
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cocoklng/article/details/126319306
版权

什么是栈和队列

栈和队列是两种重要的线性结构

数据结构：线性表

特殊性：基本操作是线性表的子集，也就是功能受限的线性表，被称为限定性的数据结构

数据类型：线性表不太相同，有时候被当做一种管理数据的规则

栈(stack)

限定仅在表尾进行插入或删除操作和线性表，对栈来说表尾和表头有特殊含义。

先进后出 LIFO(Last in first out)

栈顶：表尾

栈底：表头

空栈：没有元素的空表

满栈：元素达到栈的容量

压栈,入栈：数据添加到栈中

出栈,弹栈：数据从栈中删除

功能
  • 创建栈
  • 销毁栈
  • 栈是否为空
  • 栈是否为满
  • 入栈
  • 出栈
  • 查找栈顶元素
  • 求元素数量
顺序栈
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#define TYPE int

typedef struct StackArray
{
	TYPE* base;
	int top;
	size_t cap;
}StackArray;

// 创建栈
StackArray* create_stack(size_t cap)
{
	// 之所以使用成员指针是为了兼顾笔试题
	StackArray* stack = malloc(sizeof(StackArray));
	stack->base = malloc(sizeof(TYPE)*cap);
	stack->cap = cap;
	// 初始值值决定的栈空、栈满、入栈、查看栈顶时的top的操作,
	stack->top = -1; 
	return stack;
}

// 销毁栈
void destroy_stack(StackArray* stack)
{
	free(stack->base);
	free(stack);
}

// 判断栈是否为空
bool empty_stack(StackArray* stack)
{
	// 因为top的初始值是-1
	return 0 > stack->top;
}

// 判断栈是否为满
bool full_stack(StackArray* stack)
{
	// 同上
	return stack->cap == stack->top+1;
}

// 入栈
bool push_stack(StackArray* stack,TYPE val)
{
	if(full_stack(stack))
		return false;

	// 同上
	stack->base[++stack->top] = val;
	return true;
}

// 出栈
bool pop_stack(StackArray* stack)
{
	if(empty_stack(stack))
		return false;

	stack->top--;
	return true;
}

// 计算栈元素数量
size_t size_stack(StackArray* stack)
{
	return stack->top+1;
}

// 查看栈顶
bool top_stack(StackArray* stack,TYPE* ptr)
{
	if(empty_stack(stack))
		return false;
	
	*ptr = stack->base[stack->top];
	return true;
}

int main(int argc,const char* argv[])
{
	int num;
	StackArray* stack = create_stack(10);
	for(int i=0; i<10; i++)
	{
		push_stack(stack,i);
		if(top_stack(stack,&num))
			printf("top %d\n",num);
	}
	printf("----------------------\n");
	while(!empty_stack(stack))
	{
		top_stack(stack,&num);
		printf("top %d\n",num);
		pop_stack(stack);
	}
	return 0;
}
链式栈
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

typedef struct StackList
{
	Node* top;
	size_t cnt;
}StackList;

// 创建栈
StackList* create_stack(void)
{
	StackList* stack = malloc(sizeof(StackList));
	stack->top = NULL;
	stack->cnt = 0;
	return stack;
}

// 销毁栈
void destroy_stack(StackList* stack)
{
	while(NULL!=stack->top)
	{
		Node* node = stack->top;
		stack->top = node->next;
		free(node);
	}

	free(stack);
}

// 栈空
bool empty_stack(StackList* stack)
{
	return NULL == stack->top;
}

// 入栈
void push_stack(StackList* stack,TYPE data)
{
	Node* node = create_node(data);
	node->next = stack->top;
	stack->top = node;
	stack->cnt++;
}

// 出栈
bool pop_stack(StackList* stack)
{
	if(empty_stack(stack))
		return false;
	
	Node* node = stack->top;
	stack->top = node->next;
	free(node);
	stack->cnt--;
	return true;
}

// 查看栈顶
TYPE top_stack(StackList* stack)
{
	return stack->top->data;
}

// 元素数量
size_t size_stack(StackList* stack)
{
	return stack->cnt;
}

int main(int argc,const char* argv[])
{
	StackList* stack = create_stack();
	for(int i=0; i<10; i++)
	{
		push_stack(stack,i);
		if(!empty_stack(stack))
			printf("top %d\n",top_stack(stack));
	}
	printf("-------------------\n");
	while(!empty_stack(stack))
	{
		printf("top %d\n",top_stack(stack));
		pop_stack(stack);
	}
	
	return 0;
}
常考的笔试题
  • 入栈顺序：1 2 3 4 5
  • 出栈顺序：4 1 2 3 5
检测出栈入栈的代码
typedef struct Stack{
    int* data;
    int top;
    int cap;
}Stack;
void push_stack(Stack* stack,int val)
{
    stack->data[stack->top] = val;
    stack->top++;
}

bool pop_stack(Stack* stack)
{
    if(stack->top<=0)
        return -1001;
    stack->top--;
    return stack->data[stack->top];
}

int top_stack(Stack* stack)
{
    if(stack->top<=0)
    {
        return -1001;
    }
    return stack->data[stack->top-1];
}


bool IsPopOrder(int* pushV, int pushVLen, int* popV, int popVLen ) {
    Stack* stack = malloc(sizeof(Stack));
    stack->cap = 1000;
    stack->top = 0;
    stack->data = malloc(sizeof(int)*1000);
    int index = -1;
    for(int i=0,j=0;i<pushVLen;i++)
    {
        int val;
        push_stack(stack,pushV[i]);
        index++;
        while(index>=0 && top_stack(stack) == popV[j])
        {
            index--;
            j++;
            pop_stack(stack);
        }
    }
    return 0>index;
}
栈的应用
  • 内存管理：比如栈内存，因为它遵循着栈的后进先出的规则，它支持着函数调用，函数在传参数就是把参数先压入到栈内存，等跳转过去后再把参数先压到栈内存，等跳转过去后再把参数从栈内存弹出
  • 特殊的算法，例如：进制转换，表达式解析，迷宫求解

队列

与栈相反，先进先出的线性表，有且只有两个端口

队尾：只能添加的端口

队头：只能删除的端口

出队：删除数据

入队：添加数据

队列功能
  • 创建队列
  • 销毁队列
链式队列
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct Node
{
	TYPE data;
	struct Node* next;
}Node;

Node* create_node(TYPE data)
{
	Node* node = malloc(sizeof(Node));
	node->data = data;
	node->next = NULL;
	return node;
}

typedef struct QueueList
{
	Node* front;
	Node* rear;
}QueueList;

// 创建队列
QueueList* create_queue(void)
{
	QueueList* queue = malloc(sizeof(QueueList));
	queue->front = NULL;
	queue->rear = NULL;
	return queue;
}

// 销毁队列
void destroy_queue(QueueList* queue)
{
	while(NULL != queue->front)
	{
		Node* node = queue->front;
		queue->front = node->next;
		free(node);
	}
	free(queue);
}

// 判断队列是否为空
bool empty_queue(QueueList* queue)
{
	return NULL == queue->front;
}

// 入队
void push_queue(QueueList* queue,TYPE data)
{
	Node* node = create_node(data);
	if(empty_queue(queue))
	{
		queue->front = node;
		queue->rear = node;
		return;
	}

	queue->rear->next = node;
	queue->rear = node;
}

// 出队
bool pop_queue(QueueList* queue)
{
	if(empty_queue(queue))
		return false;

	Node* node = queue->front;
	queue->front = node->next;
	free(node);
}

// 查看队头元素，调用该函数前要先判断队列是否为空，否则就会使用到空指针
TYPE front_queue(QueueList* queue)
{
	return queue->front->data;
}

// 查看队尾元素，调用该函数前要先判断队列是否为空，否则就会使用到野指针
TYPE rear_queue(QueueList* queue)
{
	return queue->rear->data;
}

// 队列元素数量
size_t size_queue(QueueList* queue)
{
	size_t size = 0;
	for(Node* n=queue->front; NULL!=n; n=n->next)
	{
		size++;
	}
	return size;
}

int main(int argc,const char* argv[])
{
	QueueList* queue = create_queue();
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	return 0;
}
顺序队列
带计数器版本的循环队列
优点
  1. 解决了计算元素数量的问题
  2. 解决了判断队列空，满状态的问题
缺点
  1. 增加了一个成员，在入队和出队的时候都要判断
代码
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct QueueArray
{
	TYPE* base;
	int front;
	int rear;
	size_t cnt;
	size_t cap;
}QueueArray;

// 创建队列
QueueArray* create_queue(size_t cap)
{
	QueueArray* queue = malloc(sizeof(QueueArray));
	queue->base = malloc(sizeof(TYPE)*cap);
	queue->cap = cap;
	queue->front = 0;
	queue->rear = -1;
	queue->cnt = 0;
	return queue;
}

// 销毁队列
void destroy_queue(QueueArray* queue)
{
	free(queue->base);
	free(queue);
}

// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
	return 0 == queue->cnt;
}

// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
	return queue->cnt == queue->cap;
}

// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
	if(full_queue(queue))
		return false;

	queue->rear = (queue->rear+1)%queue->cap;
	queue->base[queue->rear] = data;
	queue->cnt++;
	return true;
}

// 出队
bool pop_queue(QueueArray* queue)
{
	if(empty_queue(queue))
		return false;

	queue->front = (queue->front+1)%queue->cap;
	queue->cnt--;
	return true;
}

// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
	return queue->base[queue->front];
}

// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
	return queue->base[queue->rear];
}

// 队列元素数量
size_t size_queue(QueueArray* queue)
{
	return queue->cnt;
}

int main(int argc,const char* argv[])
{
	QueueArray* queue = create_queue(10);
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	printf("---------------------\n");
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	destroy_queue(queue);
	return 0;
}
不带计数器版本的循环队列

问题

  • 如何判断队列空，满状态

    前提：队头初始化front = 0,队尾初始化rear = 0;

    队列空状态：front == rear;

    队列满状态：front == rear;

    解决办法:队列空一个位置不使用，所以队列满的状态front == rear+1

  • 如何计算队列元素数量

    (rear-front+cap)%cap

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define TYPE int

typedef struct QueueArray
{
	TYPE* base;
	int front;
	int rear;
	size_t cap;
}QueueArray;

// 创建队列
QueueArray* create_queue(size_t cap)
{
	QueueArray* queue = malloc(sizeof(QueueArray));
	queue->base = malloc(sizeof(TYPE)*cap+1);
	queue->cap = cap+1;
	queue->front = 0;
	queue->rear = 0;
	return queue;
}

// 销毁队列
void destroy_queue(QueueArray* queue)
{
	free(queue->base);
	free(queue);
}

// 判断队列是否为空
bool empty_queue(QueueArray* queue)
{
	return queue->front == queue->rear;
}

// 判断队列是否为满
bool full_queue(QueueArray* queue)
{
	return queue->front == (queue->rear+1)%queue->cap;
}

// 入队
bool push_queue(QueueArray* queue,TYPE data)
{
	if(full_queue(queue))
		return false;

	queue->base[queue->rear] = data;
	queue->rear = (queue->rear+1)%queue->cap;
	return true;
}

// 出队
bool pop_queue(QueueArray* queue)
{
	if(empty_queue(queue))
		return false;

	queue->front = (queue->front+1)%queue->cap;
	return true;
}

// 查看队头元素,判断队列是否为空
TYPE front_queue(QueueArray* queue)
{
	return queue->base[queue->front];
}

// 查看队尾元素
TYPE rear_queue(QueueArray* queue)
{
	return queue->base[(queue->rear-1+queue->cap)%queue->cap];
}

// 队列元素数量
size_t size_queue(QueueArray* queue)
{
	return (queue->rear-queue->front+queue->cap)%queue->cap;
}

int main(int argc,const char* argv[])
{
	QueueArray* queue = create_queue(10);
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	printf("---------------------\n");
	for(int i=0; i<10; i++)
	{
		push_queue(queue,i);
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
	}
	printf("---------------------\n");
	while(!empty_queue(queue))
	{
		printf("front:%d rear:%d\n",
			front_queue(queue),
			rear_queue(queue));
		pop_queue(queue);
	}
	destroy_queue(queue);
	return 0;
}
队列的应用

一般用于业务处理

  • 银行叫号系统
  • 12306购票系统
  • 电商的订单处理系统
cocoklng
关注
数据结构之栈和队列
weixin_45699237的博客
02-19 2892
1、栈 1.1 概念 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈 顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据在栈顶。 ...
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 25万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构栈和队列总结
2201_76036122的博客
06-03 1211
栈：仅在表尾进行插入和删除操作的线性表栈和队列都是一种特殊的线性表，在线性表中我们学了顺序表和链表，因此栈也有顺序栈和链栈，我感觉链栈不是很重要，着重看了顺序栈。栈特殊在哪里？你就可以想象给手电筒换电池，最后一节电池会最先拿出来，所以记住栈的特征”后进先出”（LIFO：Last In First Out）队列：只允许在一端进行插入操作、而在另一端进行删除操作的线性表,Queue。
【数据结构】栈和队列
小羊的博客
07-12 2740
栈超超超详解
数据结构栈和队列
m0_65185254的博客
10-28 4949
数据结构作业
[C/C++]数据结构 栈和队列
m0_74910646的博客
11-18 1324
是一种特殊的线性表,其只允许在固定的一端进行插入和删除元素操作,进行数据插入和删除操作的一端称为,另一端称为,栈中的数据元素遵守的原则.
【数据结构】栈和队列超详细讲解
Become Mad的博客
05-27 2311
我们已经学习了顺序表、链表、数组等数据结构，今天我们再来认识一下栈和队列两种新的数据结构，一起来看看吧~
数据结构栈和队列的基本操作
lizhi20210729的博客
11-21 1597
前言 这一篇我就不附书上代码了，太慢。 线性表的应用 线性表的合并 int ListLength(LNode L) { int i=0; LinkList p; p=L.next; while(p) { i++; p=p->next; } return i; } void MergeList(LinkList LA,LNode LB) { int m,n,i,e; m=ListLength(*LA);n=ListLength(
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 2万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构栈和队列（参考代码）
06-18
### 数据结构栈和队列知识点解析 #### 一、栈的基本概念与操作 **栈**是一种特殊的线性表，只允许在一端进行插入和删除操作，这一端被称为栈顶，另一端被称为栈底。栈遵循先进后出（First In Last Out, FILO）的...
数据结构栈和队列相关习题及答案
04-20
数据结构栈和队列相关习题及答案
数据结构栈和队列练习题答案.doc
04-02
数据结构
数据结构栈和队列解决迷宫问题
06-07
数据结构栈和队列解决迷宫问题 本文档详细介绍了利用栈和队列解决迷宫问题的步骤，对于初学者学习数据结构能很好的进行辅导。本文档主要涉及到数据结构的两个重要概念：栈和队列，并介绍了如何使用这两个数据结构来...
Redis的数据结构
2302_81083129的博客
10-31 1001
缓存穿透、缓存雪崩、缓存击穿、Redis的数据结构及常用命令
python数据类型-8-数据结构-Queue (队列)
Lookontime的博客
10-30 332
在python数据类型系列文章中已经介绍了 python的各种数据类型，队列（Queue）是一种非常重要的数据结构，但并不是python的数据类型，队列遵循先进先出（FIFO）的原则，即先插入的元素先被移除，主要的用途是为了支持线程安全和高效的队列操作而设计的！
[数据结构]堆
2401_83816455的博客
10-29 284
堆，本质是一颗完全二叉树。代码实现可参考树的代码。
高阶数据结构--图（graph）
最新发布
2401_87257864的博客
10-31 1258
邻接顶点：在无向图中G中，若(u, v)是E(G)中的一条边，则称u和v互为邻接顶点，并称边(u,v)依附于顶点u和v；在有向图G中，若<u, v>是E(G)中的一条边，则称顶点u邻接到v，顶点v邻接自顶点u，并称边<u, v>与顶点u和顶点v相关联。E = {(x,y)|x,y属于V}或者E = {<x, y>|x,y属于V && Path(x, y)}是顶点间关系的有穷集合，也叫。是无序的，顶点对(x,y)称为顶点x和顶点y相关联的一条边，这条边没有特定方向，(x, y)和(y，x)
数据结构栈和队列：基本运算与应用
"队列的基本运算-数据结构栈和队列PP" 在计算机科学中，数据结构是组织和存储数据的方式，以便高效地访问和修改。本资源主要关注两种特殊的数据结构：栈和队列，它们都是线性数据结构的变体。 栈是一种“后进先出...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值