栈与队列

于 2023-07-27 17:58:21 发布
阅读量180 收藏 13
点赞数 14
分类专栏： 数据结构 文章标签： 数据结构 链表 visual studio c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Snow_Dragon_L/article/details/131954532
版权

栈与队列

一、栈

1、 概念

栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。

2、栈存取数据的方式

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

3、栈的结构

在这里插入图片描述

4、栈的实现

栈一般可以使用数组或者链表的结构来实现，相对于链表，用数组的结构来实现会更优一些。因为数组在尾上插入数据的代价比较小。而链表要想找到链表的尾部元素需要遍历一遍链表或者是使用双向循环链表，而这会导致实现起来比较麻烦。

二、模拟实现栈

1、实现栈的头文件

（1）使用头文件的原因

因为实现栈的函数比较多，我们对实现栈的函数进行测试时也会有一些代码，而把这些东西都写在同一个文件里就会显得比较杂乱。所以使用一个头文件包含实现过程中的函数声明与头文件包含等等。

队列使用头文件的原因与栈一致，下面不再说明。

（2）代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#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);
// 打印栈
void StackPrint(Stack* ps);

（3）头文件中结构体的实现原理

因为此处实现的栈是支持动态增长的栈，所以定义一些变量，a是用来存储数据的，但存储数据的类型可能不是int，所以将int类型重定义为STDataType，方便后续按需要修改存储数据的类型，用top表示栈顶的下标，用capacity表示已经开辟的空间数量，每个空间的大小为存储在a中的元素的大小。将这三个东西封装成一个结构体，方便在后面的函数中使用。

2、对栈初始化的函数实现

（1）代码

void StackInit(Stack* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

（2）实现原理

因为一开始，栈是为空的，即栈还没有开辟空间，所以a这个指针可以置为空，此时栈的容量空间为0，栈顶的下标可以初始化为0。

3、压栈的函数实现

（1）代码

void StackPush(Stack* ps, STDataType data)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
	ps->a[ps->top] = data;
	ps->top++;
}

（2）实现原理

  • 压栈的前提是栈中得有空间，所以在一开始就对栈中的空间进行判断，如果栈顶的下标top与栈的容量空间值capacity相等就说明栈满了或者是栈还没有开辟空间。
  • 如果capacity等于0，说明没有开辟空间，就返回4作为初始空间大小；如果capacity不等于0，说明栈满了，将容量扩大二倍。结果用newcapacity接收。
  • 接着用一个临时指针接收扩容后的返回值，如果该值为空指针，说明开辟失败，就直接用perror函数进行报错；反之，说明开辟成功，将它赋值给a。
  • 注意，需用临时变量接收，否则开辟失败，a会被置为空，那之前栈的地址就找不到了。
  • 最后，将data赋值给栈顶位置的元素，将栈顶下标top自增。

4、出栈的函数实现

（1）代码

void StackPop(Stack* ps)
{
					//对top进行判断，当栈中元素为空时（top == 0）直接报错
	assert(ps && ps->top > 0);
	ps->top--;
}

（2）实现原理

  • 因为是出栈，即将栈顶的元素移除，所以栈中须有元素，即栈顶不能是0（栈底），如果不满足，则出栈失败，直接报错，否则就将栈顶值top自减。
  • 因为是出栈，不需要栈最上面元素的值，且开辟的空间是一定的，所以只需对top自减就行，无需释放空间什么的。

5、打印栈中元素的函数实现

（1）代码

void StackPrint(Stack* ps)
{
	assert(ps);
	while(ps->top)
	{
		printf("%d ", ps->a[ps->top - 1]);
		StackPop(ps);
	}
	printf("\n");
}

（2）实现原理

  • 当我们为了测试压栈与出栈的函数是否编写成功，可以弄一个打印函数将栈中的全部元素打印出来。
  • 当栈为空，即栈顶下标top为0时，打印换行后函数结束。
  • 因为出栈只能从栈顶出，而栈的最后一个元素的下标比栈顶下标top少一，所以要找到该元素需对栈顶下标top减一。
  • 因为是模拟栈，所以每次打印完后要进行出栈，这样下次才能打印栈中的下一个元素。

6、获取栈顶元素的函数实现

（1）代码

STDataType StackTop(Stack* ps)
{
	assert(ps && ps->top > 0);
	return ps->a[ps->top - 1];
}

（2）实现原理

  • 获取栈顶元素，首先栈中得有元素，如果栈为空，直接报错。

7、获取栈中有效元素个数和检测栈是否为空的函数实现

（1）代码

int StackSize(Stack* ps)
{
	return ps->top;
}

int StackEmpty(Stack* ps)
{
	return ps->top == 0;
}

（2）实现原理

  • 因为top是从0开始计数的，每压栈/出栈一次，top自增/自减一次，所以，top能够代表栈中元素的个数。
  • 而当top为0，即栈顶下标等于栈底下标时，栈中自然是没有元素的。

8、销毁栈的函数实现

（1）代码

void StackDestroy(Stack* ps)
{
				//加上if语句进行判断，当a为空时不做任何操作
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->top = ps->capacity = 0;
	}
}

三、队列

1、 概念

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

2、队列的结构

在这里插入图片描述

3、实现队列的结构

  • 队列可以用数组或者链表的结构实现，使用链表的结构实现更优一些，因为如果使用数组的结构，出队列时在数组头上出数据，效率会比较低。

四、模拟实现队列

1、实现队列的头文件

（1）代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#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;
}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);

（2）使用两个结构体的原因

  • 因为队列中的每个元素需要有保存数据和指向下一个元素的功能，且队列在存储的空间中，每个元素的空间不一定是相连的。
  • 所以就用next指针指向下一个元素的地址，用data变量保存数据，为了后续按需要修改保存数据的类型，就将数据类型int重定义为QDataType，这样后续修改数据类型时就会方便许多。
  • 因为队列是从队头出队列，从队尾入队列，为了方便这两个操作，就定义两个指针分别保存队头和队尾的地址，再将它们封装起来方便使用。

2、初始化队列的函数实现

（1）代码

void QueueInit(Queue* q)
{
	q->front = q->rear = NULL;
}

（2）实现原理

  • 因为最开始时，队列是空的，所以将队头指针front、队尾指针rear都置为NULL。

3、队尾入队列的函数实现

（1）代码

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
				
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	if (q->rear == NULL)
		q->front = q->rear = newnode;
	else
	{
		q->rear->next = newnode;
		q->rear = q->rear->next;
	}
}

（2）实现原理

  • 开辟一块队列元素的空间，用一个指针指向它，对这个指针进行判空，如果为空，说明开辟空间失败，直接报错后返回。反之，开辟空间成功，可以进行入队列操作。
  • 对这块空间中保存数据的变量data进行赋值，再将它的下一位的指针置为空。
  • 对rear指针进行判断，如果为空，说明队列为空，将队头指针front 和队尾指针rear 都赋值为newnode。
  • 如果rear指针不为空，说明队列中已经有数据了，因为rear指针指向的位置是有元素的，所以rear指针的下一位next赋值为newnode，再使rear指针指向它的下一位，方便后续操作。

4、队头出队列的函数实现

（1）出队列的结构图

在这里插入图片描述

（2）代码

void QueuePop(Queue* q)
{
	assert(q && q->front);
	QNode* pop = q->front;

	if (pop == q->rear)
		q->rear = NULL;

	q->front = q->front->next;
	free(pop);
}

（3）实现原理

  • 因为是出队列，所以队列中得有数据，否则不能进行出队列的操作，即队头指针front不为空，否则直接报错。
  • 用一个指针pop保存欲出队列的元素的地址，方便在下面对这块空间进行释放。
  • 然后将队头指针front指向下一位，表明已经出（删除）了队头的那一个元素。

注意，要加上if语句以及它的内容，否则当出队列的元素是队列的最后一个元素时，rear指针将变为野指针

5、获取队列头部元素与队尾元素的函数实现

（1）代码

QDataType QueueFront(Queue* q)
{
	return q->front->data;
}

QDataType QueueBack(Queue* q)
{
	return q->rear->data;
}

（2）实现原理

  • 因为只是获取而不是出队列或者入队列，所以直接返回队头/队尾的元素的data值就行。

6、获取队列中有效元素个数的函数实现

（1）代码

int QueueSize(Queue* q)
{
	assert(q);
	int count = 0;
	while (q->front)
	{
		++count;
		QueuePop(q);
	}
	return count;
}

（2）实现原理

  • 因为实现队列用的是链表的结构，所以要统计队列中有效元素的个数只能遍历一遍队列，在每次循环时都要有进行出队列的操作，否则将是死循环计数队头的哪一个元素。
  • 当front指针为空时，说明队列已经遍历完了，接着返回统计的数字就行。

7、检测队列是否为空与销毁队列的函数实现

（1）代码

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL;
}

void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->front)
	{
		QueuePop(q);
	}
}

（2）实现原理

  • 当队头指针front 为空时，说明队列为空，反之，队列不为空。所以，返回对指针front 的判空结果就能知道队列是否为空，当队列为空，返回结果为非零，反之，返回结果为0。
  • 因为出队列时有对队列中的那个元素的空间进行释放，所以只需遍历一遍队列，并在遍历的同时调用出队列的函数就可以，这样，队列的空间就全部被释放了。

五、代码

1、模拟实现栈的头文件的代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#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);
// 打印栈
void StackPrint(Stack* ps);

2、模拟实现栈的代码

#include"stack.h"

void StackInit(Stack* ps)
{
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

void StackPush(Stack* ps, STDataType data)
{
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : 2 * ps->capacity;
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
	}
	ps->a[ps->top] = data;
	ps->top++;
}

void StackPop(Stack* ps)
{
					//对top进行判断，当栈中元素为空时（top == 0）直接报错
	assert(ps && ps->top > 0);
	ps->top--;
}

void StackPrint(Stack* ps)
{
	assert(ps);
	while(ps->top)
	{
		printf("%d ", ps->a[ps->top - 1]);
		StackPop(ps);
	}
	printf("\n");
}

STDataType StackTop(Stack* ps)
{
				//对top进行判断，当栈中元素为空时（top == 0）直接报错
	assert(ps && ps->top > 0);
	return ps->a[ps->top - 1];
}

int StackSize(Stack* ps)
{
	return ps->top;
}

int StackEmpty(Stack* ps)
{
	return ps->top == 0;
}

void StackDestroy(Stack* ps)
{
				//加上if语句进行判断，当a为空时不做任何操作
	if (ps->a)
	{
		free(ps->a);
		ps->a = NULL;
		ps->top = ps->capacity = 0;
	}
}

3、测试实现栈的函数的代码

#include"stack.h"

void test1()
{
			//入栈出栈与打印测试
	Stack st;
	StackInit(&st);
	int arr[] = { 1,2,3,4,5,6 };
	for (int i = 0; i < 6; ++i)
		StackPush(&st, arr[i]);
	//StackPrint(&st);
	//StackPrint(&st);

			//测试获取栈顶元素
	printf("%d\n", StackTop(&st));

	int ret = StackSize(&st);
	printf("%d\n", ret);

	ret = StackEmpty(&st);
	printf("%d\n", ret);

	StackDestroy(&st);
	StackPrint(&st);

}

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

4、模拟实现队列的头文件的代码

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#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;
}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);

5、模拟实现队列的代码

#include"Queue.h"

void QueueInit(Queue* q)
{
	q->front = q->rear = NULL;
}

void QueuePush(Queue* q, QDataType data)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
				//对newnode进行判空，如果为空则为开辟空间失败，直接报错
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}
	newnode->data = data;
	newnode->next = NULL;
	if (q->rear == NULL)
		q->front = q->rear = newnode;
	else
	{
		q->rear->next = newnode;
		q->rear = q->rear->next;
	}
}

void QueuePop(Queue* q)
{
	assert(q && q->front);
	QNode* pop = q->front;

	//记得加上下面的if语句，否则当出队列的元素是队列的最后一个元素时，rear指针将变为野指针
	if (pop == q->rear)
		q->rear = NULL;

	q->front = q->front->next;
	free(pop);
}

QDataType QueueFront(Queue* q)
{
	return q->front->data;
}

QDataType QueueBack(Queue* q)
{
	return q->rear->data;
}

int QueueSize(Queue* q)
{
	assert(q);
	int count = 0;
	while (q->front)
	{
		++count;
		QueuePop(q);
	}
	return count;
}

int QueueEmpty(Queue* q)
{
	assert(q);
	return q->front == NULL;
}

void QueueDestroy(Queue* q)
{
	assert(q);
	while (q->front)
	{
		QueuePop(q);
	}
}

6、测试实现队列的函数的代码

#include"Queue.h"

void test()
{
	Queue q;
	QueueInit(&q);
	QueuePush(&q, 1);
	QueuePush(&q, 2);
	QueuePush(&q, 3);
	QueuePush(&q, 4);
	QueuePush(&q, 5);

	//		//出队列测试
	//QueuePop(&q);
	//QueuePop(&q);
	//QueuePop(&q);
	//QueuePop(&q);
	//QueuePop(&q);
	//QueuePop(&q);

	//		//获取队列头部、尾部元素测试
	//printf("%d\n", QueueFront(&q));
	//printf("%d\n", QueueBack(&q));

	//		//获取队列中有效元素个数测试
	//printf("%d\n", QueueSize(&q));

	//		//检测队列是否为空的函数测试
	//printf("%d\n", QueueEmpty(&q));
	//printf("%d\n", QueueSize(&q));
	//printf("%d\n", QueueEmpty(&q));

			//销毁队列测试
	QueueDestroy(&q);
}

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

如有错误或者不清楚的地方欢迎私信或者评论指出

Snow_Dragon_L
关注
  • 14
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 10
    评论
专栏目录
数据结构——栈与队列
m0_57484470的博客
10-17 6374
数据结构栈与队列相关基础知识详解！！！
栈与队列（Java实现）
敲敲敲
01-27 1589
栈Stack 1.定义： 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则 实际应用：常见的诸如撤销操作，网页后退操作，以及开发中程序的“调用栈”操作系统栈底层 2.三个常用方法： push方法——入栈 pop方法——出栈，即将栈顶元素删除并返该元素 peek方法——返回栈顶元素 3.实现基于数组的顺序栈 为什么选用数组呢，其实链表也可
栈与队列详解
雅俗共赏
05-22 6921
目录申明1. 栈的定义1.1 栈的定义1.2 进栈出栈变化形式2. 线性表的抽象数据类型3. 线性表的顺序存储结构3. 1 顺序存储定义3. 2 顺序存储方式3. 3 数据长度与线性表长度区别3. 4 地址计算方法4. 顺序存储结构的插入与删除4.1 获得元素操作4.2 插入操作4.3 删除操作4.4 线性表顺序存储结构的优缺点5. 线性表的链式存储结构5.1 顺序存储结构不足的解决方法5.2 线性表链式存储结构定义5.3 头指针与头节点的异同5.4 线性表链式存储结构代码描述6. 单链表的读取7. 单链表
栈与队列学习总结
guoquanqin的博客
03-20 6096
栈与队列学习总结 栈 结构特点：后进者先出，先进者后出，同时栈是一种“操作受限”的线性表，只允许在一端插入和删除数据 栈既可以用数组来实现，也可以用链表来实现。用数组实现的栈，我们叫作顺序栈，用链表实现的栈，我们叫作链式栈。 时间空间复杂度分析 在入栈和出栈过程中，只需要一两个临时变量存储空间，所以空间复杂度是 O(1)。 不管是顺序栈还是链式栈，入栈、出栈只涉及栈顶个别数据的操作，所以时间复杂度都是 O(1)。 特殊情况： 对于出栈操作来说，不会涉及内存的重新申请和数据的搬移，所以出.
栈与队列的学习总结
奔跑的蜗牛
05-07 5575
栈与队列1、栈1.1栈的定义1.2栈的存储结构及实现1.2.1栈的顺序存储1.2.2栈的链式存储1.3两栈共享存储空间1.4 栈的应用（四则运算表达式求值）2、队列2.1 队列的定义2.2循环队列2.3队列的链式存储结构及实现3、栈与队列的比较 1、栈 1.1栈的定义 栈是限定仅在表尾进行插入和删除操作的线性表 1.2栈的存储结构及实现 1.2.1栈的顺序存储 1.2.2栈的链式存储 1.3两栈共...
Python栈与队列
Pert的博客
10-14 898
栈： 栈**（也称******下压栈******、堆栈）是******仅允许在表尾****进行插入和删除操作的线性表。 我们把允许插入和删除的一端称为****栈顶******，另一端称为******栈底******。栈是一种******后进先出****的线性表， 简称LIFO结构。 栈的操作： Stack() 创建一个新的空栈 push(item)添加一个新的元素item到栈顶 pop()弹出栈顶元素 peek()返回栈顶元素 is_empty()判断栈是否为空 size()返回栈的元素个数 队列：.
ADT栈与队列的C语言编程与实现
热门推荐
timerring的博客
07-10 5万+
一 、目的：加深对抽象数据类型 ADT 栈和队列的理解；二 、环境：operating system version：Win11CPU instruction set: x64Integrated Development Environment：Viusal Studio 2022三 、内容：编写程序实现ADT栈的定义，及常用操作（数组或指针实现1) 生成栈2) Push3) Pop编写程序实现ADT队列的定义，及常用操作：1) 生成队列2) Enqueues 入列3) Isempty 判断是否队列为空
Java语言---栈与队列
tq02的博客
05-16 1561
栈的两种实现方法以及队列的实现方法
栈与队列（超详细）
qq_45792749的博客
03-29 1万+
目录一、栈（Stack）什么是栈？栈的常见方法一级目录一级目录 一、栈（Stack） 什么是栈？ 栈其实就是一种数据结构 - 先进后出（先入栈的数据后出来，最先入栈的数据会被压入栈底） 什么是java虚拟机栈？ java虚拟机栈只是JVM当中的一块内存，该内存一般用来存放 例如：局部变量 当调用函数时，我们会为函数开辟一块内存，叫做 栈帧，在 java虚拟机栈中开辟，具体如下。 常见考点：不可能的出栈顺序 这道题该怎么分析呢？ 首先我们知道，出栈时拿到的第一个元素为4，那么4必须入栈，因为入栈的顺序是
栈与队列的定义与区别
qq_65712284的博客
02-13 8738
1、栈 首先，普通的线性表实现是有两个端口可以访问的，但是如果作为栈就要封闭一端，只能访问另一端。这当然不是自讨苦吃，栈是一种抽象数据结构，是对现实世界对象的模拟。比如，自助餐厅中的一叠盘子，新盘子放在这一叠盘子的最上面，取得时候也是从最上面取。将其抽象出来就是栈，这是最合适的抽象方式。 基于栈的操作非常简单： 将数据压入栈顶-push 将栈顶数据弹出-pop 查看栈顶数据-top 栈的实现不是难点，基于栈的操作也很简单，重点是栈的运用。 动态图： 伪代码如下： large...
栈与队列。
10-11
栈和队列是两种重要的线性结构，定义，表示方法，代码实现
栈与队列的基本操作
11-11
1. 掌握栈的先进后出的特点。 2. 掌握栈的初始化、进栈、退栈、取栈顶、判栈空等基本操作。 3. 运用栈的基本操作解决一些简单的实际问题。 4. 掌握队列的先进先出的特点。 5. 掌握队列的初始化、入队、出队、取队首...
如何使用JavaScript实现栈与队列
10-16
【栈与队列的基本概念】 栈和队列是两种基础且重要的数据结构，在JavaScript以及其他编程语言中广泛应用。栈被称为“后进先出”（LIFO，Last In First Out）的数据结构，而队列则被称为“先进先出”（FIFO，First ...
栈与队列.zip
最新发布
04-06
在实际编程中，栈和队列常与其他数据结构结合使用，如栈与队列的组合可以实现优先队列，通过调整元素的入栈和出栈顺序来达到优先级的处理。此外，它们也是图论算法（如深度优先搜索DFS和广度优先搜索BFS）中的关键...
栈与队列.ppt
11-19
c语言中栈和队列的编码规则，如何编写c语言，一些具体事例。
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
C++中栈与队列的函数
12-22
栈的应用： 　头文件include 　定义栈 　stack<type>q; 　其中type是栈中数据的类型、q是定义的栈的名字； 　比较常用的函数： 　q.push();将元素压入栈中； 　q.pop(); 将栈顶元素删除； 　q.empty();判断...
自定义的栈与队列
01-04
本文将深入探讨自定义的栈与队列的实现，以及如何利用这两个数据结构的特性来解决问题。 首先，栈（Stack）是一种后进先出（LIFO, Last In First Out）的数据结构。它遵循“先进后出”的原则，类似于现实生活中的堆...
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
栈与队列：数据结构与应用实例
"本文主要介绍了栈与队列这两种基本的线性数据结构，包括它们的定义、表示方法、代码实现及应用实例。栈是只允许在表尾进行插入和删除的线性表，称为后进先出（LIFO）结构；而队列则是一种先进先出（FIFO）的数据...
评论 10
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值