05线性表之栈和队列

最新推荐文章于 2023-07-19 16:41:07 发布
最新推荐文章于 2023-07-19 16:41:07 发布
阅读量384 收藏 1
点赞数 3
分类专栏： 数据结构（C语言实现） 文章标签： 数据结构 队列 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52670477/article/details/119336651
版权

栈和队列也是线性表的两种不同的形式，它们的实现方式和顺序表与链表类似，但是在逻辑结构上有一些差别。

文章目录

栈

栈是一种特殊的线性表。栈的形式类似于弹夹，其只允许在固定的一端进行插入和删除元素操作。也就是说只允许在出口（弹夹顶部）插入元素（放入子弹）和删除元素（发射子弹）。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。

压栈：栈的插入操作叫做进栈/压栈/入栈，存入的数据在栈顶。
出栈：栈的删除操作叫做出栈。输出数据也在栈顶。

由于栈的这些特性，它的数据遵守先进后出或者后进先出的原则。

在这里插入图片描述

了解了栈的逻辑，再来看一下下面的问题：

若进栈序列为 1,2,3,4 ，进栈过程中可以出栈，则下列不可能的一个出栈序列是（）
A 1,4,3,2 
B 2,3,4,1 
C 3,1,4,2 
D 3,4,2,1


A:1入栈后出栈，然后2,3,4入栈，4,3,2出栈
B：1,2入栈，2出栈，3入栈后出栈，4入栈后出栈，最后1出栈
C：错误
D：1,2,3入栈，3出栈，4入栈，4,2,1出栈

栈的实现可以采用顺序表或者单向链表的方式：
顺序表的形式就是采用类似数组的方式，顺序表的开头作为栈底，它的尾部作为栈顶，每次入栈出栈的过程就相当于顺序表的尾插尾删的过程，由于顺序表有一个记录大小的size变量，可以直接访问到最后一个元素，因此可以很轻松的实现尾插和尾删，时间复杂度是O（1）。
链表的形式有单链表和双向链表两种，单链表有头去做栈顶效率更高，因为头插头删的时间复杂度是O（1）。如果用尾做栈顶，双向量表会更好一些，因为单链表的尾删时间复杂度为O（N）。

因此采用顺序表和链表的形式都没问题，但相比之下顺序表的形式效率更高一些，因为链表每次都需要开辟新的节点。

栈的顺序表形式实现

  • 声明栈的内容
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;//存放数据的指针
	int top;//用来记录栈顶的位置，类似于顺序表的size，
	int capacity;//容量
}ST;
  • 初始化
//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);//申请空间
	if (ps->a == NULL)//申请空间失败的情况
	{
		exit(-1);
	}
	ps->capacity = 4;
	//top初始为0，top指向栈顶元素的下一个元素，top初识为-1，top指向栈顶的元素
	ps->top = 0;
}
  • 入栈
//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)//如果栈的空间已满则增容
	{
		STDataType* tmp = realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)//增容失败的情况
		{
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;//在栈顶存放数据
	ps->top++;
}
  • 出栈
//出栈
void StackPop(ST* ps)
{
	assert(ps);
	ps->top--;
}
  • 获取栈顶的元素
//获取栈顶的数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top>0);//由于top这里指向栈顶元素的下一个元素位置，因此top为0则代表没有元素
	return ps->a[ps->top - 1];
}
  • 获取数据的个数
//求数据的个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;//top记录了元素的个数
}
  • 判断栈是否为空
//判断是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;//如果top为0则代表为空，此时返回true，否则返回false
}
  • 销毁栈
//销毁
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

栈函数的调用情况：
在这里插入图片描述

栈的测试代码

  • Stack.h
#pragma once
#include<stdio.h>
#include<stdbool.h>
#include<assert.h>

typedef int STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST;

//初始化
void StackInit(ST* ps);

//销毁
void StackDestory(ST* ps);

//入栈
void StackPush(ST* ps, STDataType x);

//出栈
void StackPop(ST* ps);
//取栈顶的数据
STDataType StackTop(ST* ps);
//求数据的个数
int StackSize(ST* ps);
//判断是否为空
bool StackEmpty(ST* ps);
  • Stack.c
#include"Stack.h"


//初始化
void StackInit(ST* ps)
{
	assert(ps);
	ps->a = (STDataType*)malloc(sizeof(STDataType*) * 4);
	if (ps->a == NULL)
	{
		exit(-1);
	}
	ps->capacity = 4;
	//top初始为0，top指向栈顶元素的下一个元素，top初识为-1，top指向栈顶的元素
	ps->top = 0;
}

//销毁
void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

//入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = realloc(ps->a, ps->capacity * 2 * sizeof(STDataType*));
		if (tmp == NULL)
		{
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}
	ps->a[ps->top] = x;
	ps->top++;
}

//出栈
void StackPop(ST* ps)
{
	assert(ps);
	ps->top--;
}
//取栈顶的数据
STDataType StackTop(ST* ps)
{
	assert(ps);
	assert(ps->top>0);
	return ps->a[ps->top - 1];
}
//求数据的个数
int StackSize(ST* ps)
{
	assert(ps);
	return ps->top;
}
//判断是否为空
bool StackEmpty(ST* ps)
{
	assert(ps);
	return ps->top == 0;
}
  • test.c
#include"Stack.h"


void test()
{
	ST st;
	StackInit(&st);
	StackPush(&st, 1);
	StackPush(&st, 2);
	printf("%d ", StackTop(&st));
	StackPop(&st);
	printf("%d ", StackTop(&st));
	StackPop(&st);
	StackPush(&st, 3);
	StackPush(&st, 4);
	while (!StackEmpty(&st))
	{
		printf("%d ", StackTop(&st));
		StackPop(&st);
	}
	StackDestory(&st);

	

}

int main()
{
	test();
	return 0;
}

队列

队列与栈不同，队列是只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表。
入队列：进行插入操作的一端称为队尾 ，出队列：进行删除操作的一端称为队头。

因此队列遵守先进先出的原则。
在这里插入图片描述

队列也可以使用顺序表和链表两种方式实现。
但是顺序表的头作为队头，出数据的时候相当于头删，时间复杂度为O（N）。

单链表的头删效率高，尾插的效率较低，但是如果使用一个头指针和尾指针指向单链表的头结点和尾结点，那么它出队和入队的时间复杂度为O（1），效率相对较高。

明白了队列的基本逻辑，就可以代码实现了，队列一般需要一个头指针和一个尾指针来指向队头和队尾的数据。

队列的单链表实现

  • 声明队列
typedef int QDataType;

typedef struct QueueNode;

typedef struct QueueNode
{
	struct QueueNode* next;//指向下一个节点
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;//头指针，指向第一个节点
	QNode* tail;//尾指针，指向最后一个节点
}Queue;
  • 定义一个队列变量
Queue q;
  • 初始化
//初始化
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
}
  • 入队
/队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));//创建新的节点
	if (newnode == NULL)//创建失败的情况
	{
		exit(-1);
	}
	newnode->data = x;//存入数据
	newnode->next = NULL;//新创建的节点的指向的节点为空
	if (pq->tail == NULL)//没有节点的情况
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;//原来的队尾指向新的节点
		pq->tail = newnode;//队尾改成新的节点
	}

}

在这里插入图片描述

  • 出队
//队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	//如果只有一个节点，释放后就没有节点了
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;//由于没有节点，头指针和尾指针都为空
	}
	else
	{
		//保存下一个节点
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;//头指针指向下一个节点
	}
}

在这里插入图片描述

  • 获取队头的数据
//取队头的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);//防止没有节点的情况出现
	return pq->head->data;
}
  • 获取队尾的数据
//取队尾的数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);//防止没有节点的情况出现
	return pq->tail->data;
}
  • 获取数据的个数
//个数
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}
  • 判断是否为空
//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;//如果head为NULL则说明链表为空，返回true，否则返回false
}
  • 销毁队列
//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;//保存下一个节点
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;//头尾指针都置为空
}

队列函数调用情况：
在这里插入图片描述

队列测试代码

  • Queue.h
#pragma once

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

typedef int QDataType;

typedef struct QueueNode;

typedef struct QueueNode
{
	struct QueueNode* next;//指向下一个节点
	QDataType data;
}QNode;

typedef struct Queue
{
	QNode* head;//头指针，指向第一个节点
	QNode* tail;//尾指针，指向最后一个节点
}Queue;

//初始化
void QueueInit(Queue* pq);

//销毁
void QueueDestory(Queue* pq);

//队尾入
void QueuePush(Queue* pq, QDataType x);

//队尾出
void QueuePop(Queue* pq);

//取队头的数据
QDataType QueueFront(Queue* pq);
//取队尾的数据
QDataType QueueBack(Queue* pq);

//个数
int QueueSize(Queue* pq);

//判空
bool QueueEmpty(Queue* pq);
  • Queue.c
#include"Queue.h"

//初始化
void QueueInit(Queue* pq)
{
	assert(pq);

	pq->head = NULL;
	pq->tail = NULL;
}

//销毁
void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->head = pq->tail = NULL;
}

//队尾入
void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		exit(-1);
	}
	newnode->data = x;
	newnode->next = NULL;
	if (pq->tail == NULL)
	{
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}

}

//队头出
void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	//如果只有一个节点，释放后就没有节点了
	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;//由于没有节点，头指针和尾指针都为空
	}
	else
	{
		//保存下一个节点
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;//头指针指向下一个节点
	}
	
}

//取队头的数据
QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->head->data;
}
//取队尾的数据
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->head);
	return pq->tail->data;
}
//个数
int QueueSize(Queue* pq)
{
	assert(pq);
	int size = 0;
	QNode* cur = pq->head;
	while (cur)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

//判空
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->head == NULL;
}
  • test.c
#include"Queue.h"


void test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	printf("%d ", QueueFront(&q));
	printf("%d ", QueueFront(&q));
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	printf("%d ", QueueFront(&q));
	printf("%d ", QueueFront(&q));
	QueuePop(&q);
	QueuePush(&q, 4);
	QueuePush(&q, 5);
	QueuePush(&q, 6);
	while (!QueueEmpty(&q))
	{
		printf("%d ", QueueFront(&q));
		QueuePop(&q);
	}
	QueueDestory(&q);
}
int main()
{

	test();

	return 0;
}
今天也要写bug、
关注
  • 3
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
数据结构中 线性表，栈，队列，算法之间的联系与区别
qq_35810838的博客
11-25 3440
一。链表为什么需要         在程序中，经常需要将一种（通常是同为某个类型的）数据元素作为整体管理和使用，需要创建这种元素组，用变量记录他们，传进传出函数等。一组元素可能发生变化（像增加或删除元素。）        对于这种需求，最简单的解决方案便是将这样一组元素看成一个序列，用元素在序列里的位置和顺序，表示实际应用中的某种意义的信息，或者表示数据之间的某种关系。        这样的...
线性表、队列和栈
LuckyMeizai的博客
05-23 583
集合操作------线性表1、 List2、 List的排序3、 队列和栈List：1、 get和setList除了继承Collection定义的方法外，还根据其线性表的数据结构定义了一系列方法，其中最常用的就是基于下表的get和set方法：--E get(int index)：获取集合中指定下标对应的元素，下标从0开始。--E set(intindex,E element)：将给定元素存入给定位...
栈和队列的详解
仓小小鼠
05-08 320
碎碎念：今天在学习数据结构，刷Leetcode的时候偶尔栈和队列不会了，还得刷，正所谓勤能补拙是良训，一分辛苦一分才。 这里感谢大佬的博客1.http://c.biancheng.net/data_structure/stack_queue/。 2.https://blog.csdn.net/whl190412/article/details/94565236 3.https://blog.csdn.net/wyqwilliam/article/details/82725637 本人对其加以理解并整.
数据结构问答3
最新发布
qq_54809548的博客
07-19 1005
区别：线性表可以在中间和两端任何地方插入和删除元素，而栈只能在同一端插入和删除元素，具有后进先出的特点、队列只允许在一段插入元素，另一端删除元素，具有先进先出的特点。但循环队列中出队元素的空间可能被后来进队的元素覆盖，如果算法要求在队列操作结束后利用进队的所有元素实现某种功能时，此时循环队列就不适合了。答：在实际应用中，一般栈和队列都是用来存放临时数据的，如果先保存的元素先处理，应该采用队列；判满：top==maxsize-1；
栈和队列以及线性表的区别
热门推荐
小米mm修仙路
06-29 2万+
1.队列先进先出，栈先进后出。 2.对插入和删除操作的"限定"。 栈是限定只能在表的一端进行插入和删除操作的线性表。队列是限定只能在表的一端进行插入和在另一端进行删除操作的线性表。  从"数据结构"的角度看，它们都是线性结构，即数据元素之间的关系相同。但它们是完全不同的数据类型。除了它们各自的基本操作集不同外，主要区别是对插入和删除操作的"限定"。 栈和队列是在程序设计中被广泛使用的两种线性数据
数据结构：线性表、链表、队列、栈、串
11-24
包含数据结构中线性表、链表、队列、栈、串等几种结构的常见操作，以及顺序和链式存储过程
3. 线性表-栈和队列1
08-03
栈和队列操作受限的线性表，只能在一端（栈顶）进行插入删除操作先进后出，FILO栈的实际应用浏览器后退操作、app页面返回操作各种软件的撤销操作函数调用栈栈的基本
数据结构实验（线性表、栈、队列）
11-20
A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空 间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点有 prior，data 和 next 三个域，其中 data 为数 据域，存放元素的有效信息...
第一讲：线性表和栈队列.ppt
07-12
1、5个男生3个女生排成一排,3个女生要排在一起,有多少种不同的排法?
数据结构-线性表、栈、队列
04-21
包含JWArray和JWList，分别包含顺序结构及链式结构的线性表、栈和队列操作，函数使用方便简单，可以作为简单的C语言线性表、栈和队列操作库。
栈和队列是两种特殊的线性表，从数据逻辑结构角度看，栈和队列的元素均呈现一种线性关系
BLOG域名:programb.blog.csdn.net
03-01 3941
队列（简称队）也是一种运算受限的线性表，在这种特殊的线性表上，插入限定在表的某一端进行，删除限定在表的另一端进行。队列的插入操作称为进队，删除操作称为出队。允许插入的一端称为队尾，允许删除的一端称为队头。新插入的元素只能添加到队尾，被删除的只能是排在队头的元素。从数据逻辑结构的角度看，栈和队列的元素确实都呈现一种线性关系。但它们在数据操作方式上有所不同，这使得它们具有不同的特性。正是这种受限的元素插入和删除运算，使得队列表现出先进先出或者后进后出的特点。
线性表、链表、栈、队列的关系
奋斗的程序猿的博客
05-16 1万+
程序员在编程实战操作面前有两个拦路虎，第一个是用递归的思想去解决问题，第二个是数据结构与算法的应用。对于递归，由于其神奇的薄面纱总是然我们觉得难以理解，而大多数递归解法还是需要承担一定的计算负担的，因此我觉得能理解其思想与用法固然好，但是实在无法理解也只能慢慢适应。而对于第二个难题，数据结构与算法基本上每一个程序员都需要了解，因为，算法是解答一个问题的基本逻辑，如果你可以证明这个逻辑是正确的，那接下来的问题就是应该采用什么样的数据结构来保证你的程序能有最高的执行效率，即比较好的时间复杂性，同样内存空间消耗也
【数据结构】栈的介绍
WINGREZ‘S BLOG
08-01 1137
参考资料：《数据结构（C语言版）严蔚敏著》 版权说明：未经作者允许，禁止转载。如引用本文内容，需标明作者及出处。如本文侵犯了您的权益，请联系我删除并致歉。 文章说明：如文章中出现错误，请联系我更改。如您对文章的内容有任何疑问，也欢迎来与我讨论。 本文正在施工中...请稍等... 栈的介绍 基本概念 1、栈：栈是一种特殊的线性表，它只允许表尾端进行插入或删除操作。 2、栈顶：栈允许进行插入或删...
考研数据结构---线性表---栈
PigWord的博客
07-13 609
栈 1.栈是一种线性表，主要特点就是只允许在一端进行插入或删除操作的线性表。 2.栈顶：（top）线性表允许进行插入和删除的一端 栈底:(bottom) 是固定的，不允许进行插入和删除的一端 一、栈的顺序存储实现 采用顺序存储的栈被称为“顺序栈”,通常顺序存储结构由一个“一维数组”和一个记录“栈顶”元素位置的变量组成。 1.结构定义 #define MaxSize 100 typedef int...
3）数据结构之线性表（栈与队列）
qq_42591783的博客
07-29 943
栈与队列的本质 栈与队列都是属于线性表，那么它们的逻辑结构必定是连续的
简述栈和队列的共同点和不同点.它们与线性表有什么关系
snowyuuu的博客
08-18 1万+
栈和队列都是线性表，都是限制了插入删除点的线性表（或者说是控制了访问点的线性表） 　　共同点：都是只能在线性表的端点插入和删除 　　不同点：栈的插入和删除都在线性表的同一个端点，该点通称栈顶，相应地，不能插入删除的另一个端点通称栈底，其特性是 先进后出 ...
线性表、栈和队列的相同点和不同点
weixin_42764228的博客
01-27 1万+
相同点：都是线性结构，都是逻辑结构的概念。都可以用顺序存储或链表存储；栈和队列是两种特殊的线性表，对插入、删除运算加以限制。 不同点： ①运算规则不同，线性表为随机存取，而栈是只允许在栈顶进行插入、删除运算，是后进先出表；队列是只允许在队尾进行插入、队头进行删除运算，是先进先出表； ② 用途不同，堆栈用于子程调用和保护现场，队列用于多道作业处理、指令寄存及其他运算等等 ...
栈与链表小结
weixin_43511126的博客
04-10 2463
1.栈 栈的特点就是后进先出，始终使用top和pop语句来实现每一个元素的遍历，同时在使用pop和top函数的时候，要先使用empty来判断栈是否为空。 下面为一道很经典的栈的例题 1.1 题目描述 读入一个只包含 +, -, *, / 的非负整数计算表达式，计算该表达式的值。 输入 测试输入包含若干测试用例，每个测试用例占一行，每行不超过200个字符，整数和运算符之间用一个空格...
栈与链表
weixin_37725502的博客
12-22 355
栈是一种数据结构，但是链表不是数据结构，它只是存储结构。线性表可以有顺序存储结构和链式存储结构，栈也可以有顺序存储结构和链式存储结构。
线性表、栈和队列都是什么结构
05-15
线性表、栈和队列都是数据结构中常用的基本数据类型。 线性表是指数据元素之间存在一对一的线性关系，即除了第一个和最后一个元素，其它每个元素都恰好有一个前驱和一个后继。线性表可以用顺序存储结构和链式存储...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

今天也要写bug、

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值