【数据结构】线性表之栈、队列

最新推荐文章于 2024-07-25 15:58:50 发布
最新推荐文章于 2024-07-25 15:58:50 发布
阅读量1.6k 收藏 54
点赞数 62
分类专栏： 【数据结构】 文章标签： 数据结构 链表 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_55401402/article/details/130763435
版权

在这里插入图片描述

前言

前面两篇文章讲述了关于线性表中的顺序表与链表，这篇文章继续讲述线性表中的栈和队列。
这里讲述的两种线性表与前面的线性表不同，只允许在一端入数据，一段出数据，详细内容请看下面的文章。
顺序表与链表两篇文章的链接：
线性表之顺序表
线性表之链表

注意： 本文提到的效率全部为空间复杂度！！！！

一、栈

1. 栈的概念

栈:一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO (Last ln FirstOut)的原则.
入栈:栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
出栈:栈的删除操作叫做出栈。出数据也在栈顶。

2. 栈的结构

栈的结构决定了栈只能在栈顶入数据，栈顶出数据，并且遵循着后进先出的原则。

2.1 选择数据结构完成栈（数组 or 链表)

2.1.1 数组

前面学习过顺序表就能知道，数组只有尾插和尾删的效率高为 O(1) , 而靠近头的位置的插入删除的效率比较低为O(N)。
而对于栈这种只能在栈顶插入、删除的数据结构可谓是完美契合数组的优点。
在这里插入图片描述

2.1.2 链表

前面学习过链表就可以知道，对于单链表的头插、头删的效率非常高为 O(1) , 而它的尾插、尾删需要找尾，效率比较低为 O(N)。

若以单链表的头为栈底，尾为栈顶，则入栈、出栈相当于单链表的尾插、尾删效率并不高。
显然这不是我们的最佳选项，但是若用一个变量记录尾的情况下，尾插、尾删的效率也可以达到O(1)。

在这里插入图片描述

若以单链表的头为栈顶，尾为栈底，则入栈、出栈相当于单链表的头插、头删效率非常高为O(1)。
这里与前面的数组差不多，也是栈的操作完全契合单链表的优点。

在这里插入图片描述
栈能够使用单链表实现，当然也可以用带头双向循环链表实现，但是我认为这里使用带头双向循环链表有点大炮打蚊子，大材小用的感觉。

2.1.3 我选择用数组完成栈

为什么这里选择数组完成栈呢？
明明数组容量不足时扩容需要消耗，而链表没有这个消耗，为什么不用链表？
原因有以下几点：

  1. 由于数组物理结构上是连续的，缓存命中率高，访问效率高。
  2. 相比链表，数组只需要存储数据，而链表每一个节点还需要存下一个节点的地址。
  3. 虽然数组扩容有消耗，但是链表每次申请节点的时候也会有消耗。

2.2 栈的操作

在这里插入图片描述

3. 栈的实现

Stack.h头文件的实现

#pragma once

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

// 支持动态增长的栈
typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;		// 栈顶
	int capacity;  // 容量 
}Stack;
// 初始化栈 
void StackInit(Stack* ps);
// 入栈 
void StackPush(Stack* ps, STDataType data);
// 出栈 
void StackPop(Stack* ps);
// 获取栈顶元素 
STDataType StackTop(Stack* ps);
// 获取栈中有效元素个数 
int StackSize(Stack* ps);
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps);
// 销毁栈 
void StackDestroy(Stack* ps);

Stack.c文件的实现

3.1 初始化栈

栈的初始化将传入函数的结构体进行初始化：
a. 栈顶初始化的时候注意有两种情况:
1. top指向栈顶元素
2. top指向栈顶元素的后面一个位置
当然都可以，我选择 1 仅仅方便我自己理解

b. 是否在初始化的时候给栈申请部分空间
当然都可以，我这里选择不申请空间，在后面用realloc函数申请和扩容空间。

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->capacity = 0;
	//ps->top = -1;    //top指向栈顶
	ps->top = 0;     //top指向栈顶的后面一个元素
	ps->a = NULL;
}

3.2 入栈

当数据入栈时需要判断栈是否为满，若为满则需要扩容，这里的StackFull函数其实并没有必要，由于栈只有尾插这一个插入操作不需要复用扩容操作，所以可以直接写在入栈操作中。
注意：
当realloc()函数的参数为NULL时，其作用与malloc()函数的作用一样。

void StackFull(Stack* ps)
{
	assert(ps);
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
	if (tmp == NULL)
	{
		perror("realloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = newcapacity;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
		StackFull(ps);
	ps->a[ps->top] = data;
	ps->top++;
}

3.3 判空

前面假设了top是指向栈顶元素后面一个位置，所以当 top 指向 0 的时候栈是空的。

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

3.4 出栈

执行出栈操作时，栈不能为空，且只需要 top-- ， 不需要将其数据抹除。

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则不能继续出栈
	ps->top--;
}

3.5 取栈顶元素

与出栈操作一样，取栈顶元素时，栈不能为空。
且top是指向栈顶元素后面一个位置，所以取栈顶元素时取的是 top - 1 指向的元素。

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则无栈顶元素
	return ps->a[ps->top - 1];
}

3.6 获取栈中有效元素个数

由于top是指向栈顶元素的下一个位置，而元素个数正好是下标 + 1 ，也就是top。

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;   //由于top是指向栈顶元素的下一个位置		
					  //而元素个数正好是下标 + 1 ，也就是top
}

3.7 销毁栈

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;

	ps->capacity = 0;
	ps->top = 0;
}

4. 整体代码的实现

#include "Stack.h"
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	ps->capacity = 0;
	ps->top = 0;     //top指向栈顶的后面一个元素
	ps->a = NULL;
}

void StackFull(Stack* ps)
{
	assert(ps);
	int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
	STDataType* tmp = (STDataType*)realloc(ps->a, sizeof(STDataType) * newcapacity);
	if (tmp == NULL)
	{
		perror("realloc");
		return;
	}
	ps->a = tmp;
	ps->capacity = newcapacity;
}

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	assert(ps);

	if (ps->capacity == ps->top)
		StackFull(ps);
	ps->a[ps->top] = data;
	ps->top++;
}

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);

	return ps->top == 0;
}

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则不能继续出栈
	ps->top--;
}

// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(!StackEmpty(ps));
	//栈为空，则无栈顶元素
	return ps->a[ps->top - 1];
}

// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);

	return ps->top;   //由于top是指向栈顶元素的下一个位置		
					  //而元素个数正好是下标 + 1 ，也就是top
}

// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;

	ps->capacity = 0;
	ps->top = 0;
}

二、队列

1. 队列的概念

队列:只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有 先进先出 FIFO(First In First Out) 的原则。
入队列:进行插入操作的一端称为队尾
出队列:进行删除操作的一端称为队头

2. 队列的结构

在这里插入图片描述

2.1 选择数据结构完成队列（数组 or 链表)

2.1.1 数组

前面学习过顺序表就能知道，数组只有尾插和尾删的效率高为 O(1) , 而靠近头的位置的插入删除的效率比较低为O(N)。
而对于队列这种只能在队尾插入、对头删除的数据结构，无论队头和队尾定义在哪，使用数组完成必定会有头删或头插，会使得队列的效率降低，所以不建议使用数组完成。

在这里插入图片描述

2.1.2 链表

前面学习过链表就可以知道，对于单链表的头插、头删的效率非常高为 O(1) , 而它的尾插、尾删需要找尾，效率比较低为 O(N)。

(1)若以单链表的头为队头，尾为队尾，则入队列、出队列相当于单链表的尾插、头删效率并不高。
(2)若以单链表的头为队尾，尾为队头，则入队列、出队列相当于单链表的头插、尾删效率并不高。
虽然两种情况都有一种操作效率为O(N) , 但是这两种情况都是与尾有关的操作，
所以只要在结构体中定一个记录尾的成员，那么尾插、尾删的效率就能达到O(1).

在这里插入图片描述

2.1.3 我选择用链表完成队列

为什么这里选择链表完成队列？
通过上面的讲述原因已经显而易见了。
原因如下：
由于无论怎么改造数组都会有一个操作效率为 O(N),而链表只需要改变结构体，使其多一个指向尾的成员，就能使队列的插入、删除的操作效率为O(1).

3. 队列的实现

Queue.h头文件的实现

#pragma once

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

typedef int QDataType;

// 链式结构：表示队列 
typedef struct QListNode
{
	struct QListNode* next;
	QDataType data;
}QNode;

// 队列的结构 
typedef struct Queue
{
	QNode* front;
	QNode* rear;  //指向队列最后一个元素的后面
	int size;
}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);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q);
// 销毁队列 
void QueueDestroy(Queue* q);

Queue.c文件的实现
3.1 初始化队列

这里队列的front指向队头，rear指向队尾。
当队列为空的时候，那么front和rear 都是指向 NULL。

// 初始化队列 
void QueueInit(Queue* q)
{
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

在这里插入图片描述

3.2 队尾入队列

由于使用链表实现队列，插入时需要申请一个节点。
入队列分为两种情况：

  1. 队列为空时，需要改变队头、队尾的指针。
  2. 队列不为空时，只需要将新节点接到队尾，并将尾指针向后移动即可。
// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = data;

	if (q->front == NULL)      //分队列是否有元素两种情况
	{						   //队列为空
		assert(q->rear == NULL);
		q->front = newnode;
		q->rear = newnode;
	}
	else
	{						   //队列不为空
		q->rear->next = newnode;
		q->rear = newnode;
	}

	q->size++;//入队列，队列长度加一
}
3.3 判空

当队列中的头、尾指针都指向NULL的时候为队列为空。

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL && q->rear == NULL;
}

在这里插入图片描述

3.4 队头出队列

出队列分为两种情况：

  1. 队列中只有一个元素时：删除最后一个节点，并将 front 和 rear 指向 NULL。
  2. 队列中有多个元素时：删除 front 指向的节点，并将 front 向后移动。
// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//出队列时，队列不能为空
	assert(!QueueEmpty(q));

	//当队列中只有一个元素的时候，不仅仅头指针需要改变，尾指针也需要改变
	//因为当删除最后一个元素时，首指针释放当前节点，并向后移动，而尾指针并没有移动
	//当释放后若在插入元素时，尾指针会造成野指针的情况
	if (q->front->next == NULL)
	{
		QNode* del = q->front;
		q->front = NULL;
		q->rear = NULL;
		free(del);
	}
	else
	{
		QNode* del = q->front;
		q->front = q->front->next;
		free(del);
	}
	q->size--;
}
3.5 获取队列头部元素

front 指向的节点存储着头部元素。

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->front->data;
}
3.6 获取队列队尾元素

rear 指向的节点存储着尾元素。

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->rear->data;
}
3.7 获取队列中有效元素个数

结构体中的 size 存储着队列中的有效元素个数

// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);
	//结构体中定义了一个size
	//而这里遍历链表得到个数，效率低O(N)
	/*int size = 0;  不要用
	QNode* cur = q->front;
	while (cur != q->rear)
	{
		size++;
		q->front = q->front->next;
	}*/
	return q->size;
}
3.8 销毁队列

销毁队列与前面销毁单链表相同，需要将每一个节点都释放。

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

4. 整体代码的实现

// 初始化队列 
void QueueInit(Queue* q)
{
	q->front = NULL;
	q->rear = NULL;
	q->size = 0;
}

// 队尾入队列 
void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		return;
	}
	newnode->next = NULL;
	newnode->data = data;

	if (q->front == NULL)      //分队列是否有元素两种情况
	{
		assert(q->rear == NULL);
		q->front = newnode;
		q->rear = newnode;
	}
	else
	{
		q->rear->next = newnode;
		q->rear = newnode;
	}

	q->size++;//入队列，队列长度加一
}

// 检测队列是否为空，如果为空返回非零结果，如果非空返回0 
int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL && q->rear == NULL;
}

// 队头出队列 
void QueuePop(Queue* q)
{
	assert(q);
	//出队列时，队列不能为空
	assert(!QueueEmpty(q));

	//当队列中只有一个元素的时候，不仅仅头指针需要改变，尾指针也需要改变
	//因为当删除最后一个元素时，首指针释放当前节点，并向后移动，而尾指针并没有移动
	//当释放后若在插入元素时，尾指针会造成野指针的情况
	if (q->front->next == NULL)
	{
		QNode* del = q->front;
		q->front = NULL;
		q->rear = NULL;
		free(del);
	}
	else
	{
		QNode* del = q->front;
		q->front = q->front->next;
		free(del);
	}
	q->size--;
}

// 获取队列头部元素 
QDataType QueueFront(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->front->data;
}

// 获取队列队尾元素 
QDataType QueueBack(Queue* q)
{
	assert(q);
	//获取队列头部元素时，队列不能为空
	assert(!QueueEmpty(q));

	return q->rear->data;
}


// 获取队列中有效元素个数 
int QueueSize(Queue* q)
{
	assert(q);

	//结构体中定义了一个size
	//而这里遍历链表得到个数，效率低
	/*int size = 0;    不要用
	QNode* cur = q->front;
	while (cur != q->rear)
	{
		size++;
		q->front = q->front->next;
	}*/
	return q->size;
}

// 销毁队列 
void QueueDestroy(Queue* q)
{
	assert(q);
	QNode* cur = q->front;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
}

结尾

注意： 本文提到的效率全部为空间复杂度！！！！
如果有什么建议和疑问，或是有什么错误，大家可以在评论区中提出。
希望大家以后也能和我一起进步！！🌹🌹
如果这篇文章对你有用的话，希望大家给一个三连！！🌹🌹

在这里插入图片描述

是阿建吖!
关注
  • 62
    点赞
  • 踩
  • 54
    收藏
    觉得还不错? 一键收藏
  • 48
    评论
专栏目录
【数据结构】栈和队列的总结对比
love_Aym的博客
05-05 1103
栈和队列都是特殊的线性表，只不过对插入和删除操作做了限制。栈（stack）：是限定尽在表尾进行插入和删除操作的线性表队列（queue）：是只允许在一端进行插入操作，而在另一端进行删除操作的线性表。栈和队列的相同点和不同点：1、均可以用线性表的顺序存储结构来实现，但都存在顺序存储的一些弊端，因此他们各有各自的技巧来解决这个问题：2、均可以通过链式存储结构来实现，实现原则上与线性表基本相同。总的来说...
【数据结构】线性表、栈、队列
ThetaQing的博客
09-06 251
线性表 线性表是一个含n>=0个结点的有限序列，对于其中的结点，有且仅有一个开始结点没有前驱但有一个后继结点，有且仅有一个开始结点没有后继但有一个前驱结点，其他结点都有且仅有一个前驱和一个后继结点。 分类 数据元素在内存中集中存储，采用顺序表示结构，简称“顺序存储” 数据元素在内存中分散存储，采用链式表示结构，简称“链式存储” ...
（三）数据结构-栈
weixin_45579930的博客
07-18 1638
栈-特点后进先出栈是一种先进后出的线性表，栈的插入和删除操作都只能在栈顶进行，而一般的线性表可以在线性表的任何位置进行插入和删除操作。队列-特点先进先出队列是一种先进先出的线性表，队列的插入只能在队尾进行，队列的删除只能在队头进行，而一般的线性表可以在线性表的任何位置进行插入和删除操作。.....................
数据结构（六）之 栈
坚持就是胜利的博客
01-17 264
栈 栈和队列是两种重要的数据结构.从数据结构角度上看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，他们是操作受限的线性表，因此可称为限定性数据结构.但从数据类型角度看，他们是线性表大不相同的两类重要的抽象数据类型.由于他们广泛应用在各种软件系统当中，因此在面向对象的程序设计中，他们是多型数据类型。 抽象数据类型栈的定义 栈：是限定仅在表尾进行插入或删除操作的线性表.因此，...
堆，栈，队列的区别
LVXIANGAN的专栏
12-05 2221
堆的优势是,可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。堆中主要存放用new构造的对象和数组。 栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,
数据结构——栈（概念讲解、代码实现及应用）
sjl20021006的博客
07-26 1785
一、栈的定义和特征 栈是n个元素的有限序列，且只能在一端插入和删除的线性表，当n为0时，栈为空栈 下面我们来简单的分析一下栈的特征：假设我们向空栈中依次插入元素a1到an，那么由定义可知，删除这些元素的顺序只能是从an到a1，这说明栈具有后进先出（先进后出）的特征，也可以称为“first in last out”。 二、栈的某些术语和常用运算函数 栈顶：指的是插入和删除元素的一侧，也称为top。 栈底：栈的另一端，也叫...
【线性数据结构】队列
Ampty36的博客
07-30 353
队列基础队列的特征队列的概念队列操作代码组织单调队列单调队列的作用&原理题目组织代码优先队列优先队列定义优先队列操作优先队列部分用法代码列题分析 队列(queue)一样都是线性数据结构，它的特征如下: 队列中的数有的特征，它遵循先进先出的原则，这也是栈的特征。 可以在队尾添加元素，队头添加元素，也可以队头删除元素。 基础队列的特征 队列的概念 队头和队尾:按照思想，从队头删除元素，从队尾入队元素。 入队:插入队列的操作，是元素入队。 出队:删除队列的操作，让元素出队。 我们现在有一个队列，
数据结构线性表、栈队列的思维导图.zip
08-09
通过这个"数据结构线性表、栈队列的思维导图.zip"文件，你可以深入理解这三个基本数据结构，以及它们在实际问题中的应用。思维导图的视觉化呈现能帮助你更好地掌握这些知识，并且在解决实际编程问题时能迅速回忆和...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
数据结构实验报告 线性表 串 队列 栈.doc
04-01
本实验报告的主题围绕线性表、串、队列和栈这四种基本的数据结构展开，旨在通过实践加深对这些概念的理解。线性表是一种线性的数据结构，其中元素按特定顺序排列，每个元素只有一个前驱和一个后继，除了第一个和最后...
数据结构中线性表，队列和栈
01-07
线性表、栈和队列是数据结构中的基本概念，它们在编程中有着广泛的应用。 1. 线性表： 线性表是一种最简单、最基本的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。这些元素可以按顺序存储，如数组，也...
数据结构实验（线性表、栈、队列）
11-20
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空 间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
栈的定义与部分习题讲解
weixin_56169816的博客
05-11 1072
栈 一、栈的定义 ​ 栈是一种只能在一端进行插入和删除操作的线性表，表中只允许进行插入和删除操作的一端称为栈顶。栈顶的当前位置是动态的，栈顶的当前位置是由一个成为栈顶指针的位置指示器来指示。表的另一端称为栈底。当栈中没有元素时，称为空栈，栈的插入操作称为进栈或入栈，栈的删除操作称为出栈或退栈。 如下图时队元素的进栈和出栈操作： 二、栈的特点 ​ 栈的主要特点是 “ 后进先出 ”，即后进栈的元素先出栈。栈也被称为后进先出表 三、栈的存储结构 栈有两种主要的存储结构，即顺序栈和链栈。前者采用顺序存储结构表
数据结构——线性表——栈
m0_50708613的博客
01-28 2670
一、栈 1.栈的定义 栈是只能从一端存取数据和读取数据且遵循 "先进后出" 或“后进后出”原则的线性存储结构。 2.栈的分类 与线性表存储结构类似，栈也有两种存储结构：顺序存储结构和链式存储结构。 二、栈的顺序存储结构 1.顺序栈的定义 顺序栈：即用顺序存储结构方式设计栈的存储数据，从而实现栈存储结构。 顺序栈通常有一个一维数组data和一个记录栈顶元素位置的变量top组成，底部称为栈底，头部称为栈顶。如图所示： 3.顺序栈是四要素 设顺序栈为st. (1)栈空：st.to...
线性表、栈和队列的概述
weixin_42604175的博客
09-10 1445
1.线性表 线性表的定义：零个或多个元素的有序队列。 注意：首先它是一个序列。也就是说元素之间是有序的，如果存在多个元素，则第一个元素没有前驱，最后一个元素没有后继，其他元素则有且仅有一个前驱和一个后继。 线性表中元素的个数n定义为线性表的长度，当n=0时，则线性表为空表。 注意：通常我们用一维数组来实现线性表的顺序存储结构，那么我们就要注意区分数组长度和线性表的长度； 数组长度：...
链表、栈、队列
qq_63915254的博客
11-24 1032
当慢指针刚进环时，可能就和快指针相遇了，最差情况下两个指针之间的距离刚好就是环的长度。此时，两个指针每移动一次，之间的距离就缩小一步，不会出现每次刚好是套圈的情况，因此：在满指针走到一圈之前，快指针肯定是可以追上慢指针的，即相遇。快慢指针，即慢指针一次走一步，快指针一次走两步，两个指针从链表其实位置开始运行，如果链表带环则一定会在环中相遇，否则快指针率先走到链表的末尾。队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出的特性。、非顺序的存储结构，数据元素的。
数组、链表、队列、栈数据结构特点，各自优点和缺点
三横同学的博客
03-09 706
数组、链表、队列、栈的特点与优缺点
线性结构 -- 栈
yunfan
09-15 4996
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，它们是和线性表不相同的两类重要的抽象数据类型。 一 栈的定义和特点 1.1 栈的定义 栈(Stack) 是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶(top)，相应地，表头端称为栈底(bottom)。不含元素的空表称为空栈。 1....
3.1、数据结构-线性表
最新发布
yoyo勰的博客
07-25 757
顺序列表由于元素与元素之间是相邻的，我们可以直接从首元素来查到每个元素的位置。【2021年】设有栈S和队列Q初始状态为空,数据元素序列a,b,c,d,e,f依次通过栈S,且多个元素从S出栈后立即进入队列Q,若出队的序列是b,d,f,e,c,a,则S中的元素最多时,栈底到栈顶的元素依次为()。在时间方面，由顺序表和链表的存储方式可知，当需要对元素进行破坏性操作（插入、删除）时，链表效率更高，因为其只需要修改指针指向即可，而顺序表因为地址是连续的，当删除或插入一个元素后，后面的其他节点位置都需要变动。
评论 48
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值