“栈和队列”

于 2024-05-11 14:34:20 发布
阅读量562 收藏 16
点赞数 23
分类专栏： c++ 文章标签： java 开发语言 算法 数据结构 图论 考研 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/f_2789889770/article/details/138710332
版权

栈和队列

1.栈

1.1栈的概念及结构

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

在这里插入图片描述

在这里插入图片描述

1.2栈的实现

栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

在这里插入图片描述
在这里插入图片描述

// 下面是定长的静态栈的结构，实际中一般不实用，所以我们主要实现下面的支持动态增长的栈
typedef int STDataType;
#define N 10
typedef struct Stack
{
	STDataType _a[N];
	int _top; // 栈顶
}Stack;
// 支持动态增长的栈
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);

#include "Stack.h"

void STInit(ST* pst)
{
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
		
	}

	pst->a[pst->top] = x;
	pst->top++;

}

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

2.队列

2.1队列的概念及结构

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

在这里插入图片描述

2.2队列的实现

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

在这里插入图片描述

// 链式结构：表示队列
typedef struct QListNode
{
	struct QListNode* _pNext;
	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);

#include "Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
	
	if (pq->phead->next == NULL)
	{
		free(pq->phead); 
		pq->phead = pq->ptail = NULL;
			
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;

	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}

另外扩展了解一下，实际中我们有时还会使用一种队列叫循环队列。如操作系统课程讲解生产者消费者模型时可以就会使用循环队列。环形队列可以使用数组实现，也可以使用循环链表实现。

在这里插入图片描述

3.栈和队列面试题

1. 括号匹配问题。OJ链接

typedef char STDataType;

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

// 初始化和销毁
void STInit(ST* pst);
void STDestroy(ST* pst);

// 入栈  出栈
void STPush(ST* pst, STDataType x);
void STPop(ST* pst);

// 取栈顶数据
STDataType STTop(ST* pst);

// 判空
bool STEmpty(ST* pst);
// 获取数据个数
int STSize(ST* pst);

void STInit(ST* pst)
{
	pst->a = NULL;
	pst->capacity = 0;
	pst->top = 0;
}

void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}

void STPush(ST* pst, STDataType x)
{
	assert(pst);
	if (pst->capacity == pst->top)
	{
		int newcapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail!");
			return;
		}

		pst->a = tmp;
		pst->capacity = newcapacity;
		
	}

	pst->a[pst->top] = x;
	pst->top++;

}

void STPop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	pst->top--;
}

STDataType STTop(ST* pst)
{
	assert(pst);
	assert(pst->top > 0);
	return pst->a[pst->top - 1];
}

bool STEmpty(ST* pst)
{
	assert(pst);
	return pst->top == 0;
}

int STSize(ST* pst)
{
	assert(pst);
	return pst->top;
}

bool isValid(char* s) {

    ST st;
    STInit(&st);

    while(*s)
    {
        //如果是左括号就入栈
        if((*s == '[') || (*s == '{') || (*s == '('))
        {
            STPush(&st,*s);
        }
        //否则就出栈和右括号匹配
        else
        {
            if(STEmpty(&st))
            {
                STDestroy(&st);
                return false;
            }

            STDataType tmp = STTop(&st);
            STPop(&st);
            
            if((tmp == '(' && *s != ')') 
            || tmp == '[' && *s != ']' 
            || tmp == '{' && *s != '}')
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool ret = STEmpty(&st);
    STDestroy(&st);
    return ret;
}

2. 用队列实现栈。OJ链接

typedef int QDataType;

typedef struct QueueNode
{
	struct QueueNode* next;
	QDataType val;
}QNode;

typedef struct Queue
{
	QNode* phead;
	QNode* ptail;
	int size;
}Queue;

//初始化和销毁
void QueueInit(Queue* pq);
void QueueDestroy(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);

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueueDestroy(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->phead;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}
	pq->phead = pq->ptail = NULL;
	pq->size = 0;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return;
	}

	newnode->next = NULL;
	newnode->val = x;

	if (pq->ptail == NULL)
	{
		pq->phead = pq->ptail = newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}

	pq->size++;
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->size != 0);
	
	if (pq->phead->next == NULL)
	{
		free(pq->phead); 
		pq->phead = pq->ptail = NULL;
			
	}
	else
	{
		QNode* next = pq->phead->next;
		free(pq->phead);
		pq->phead = next;

	}
	pq->size--;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->phead);
	return pq->phead->val;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->ptail);
	return pq->ptail->val;
}

int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->size == 0;
}


typedef struct {
    Queue q1;
    Queue q2;
} MyStack;


MyStack* myStackCreate() {
    MyStack* pst = (MyStack*) malloc(sizeof(MyStack));
    QueueInit(&pst->q1);
    QueueInit(&pst->q2);

    return pst;
}

void myStackPush(MyStack* obj, int x) {
    if(!QueueEmpty(&(obj->q1)))
    {
        QueuePush(&obj->q1,x);
    }
    else
    {
        QueuePush(&obj->q2,x);
    }

}

int myStackPop(MyStack* obj) {
    //假设法找不为空的队列
    Queue* empty = &obj->q1;
    Queue* nonempty = &obj->q2;

    if(!QueueEmpty(&obj->q1))
    {
        empty = &obj->q2;
        nonempty = &obj->q1;
    }

    while(QueueSize(nonempty) > 1)
    {
        QueuePush(empty,QueueFront(nonempty));
        QueuePop(nonempty);
    }

    int ret = QueueFront(nonempty);
    QueuePop(nonempty);
    return ret;
    
}

int myStackTop(MyStack* obj) {
    if(!QueueEmpty(&obj->q1))
    {
        return QueueBack(&obj->q1);
    }
    else{
        return QueueBack(&obj->q2);
    }
}

bool myStackEmpty(MyStack* obj) {
    return QueueEmpty(&obj->q1) && QueueEmpty(&obj->q2);
}

void myStackFree(MyStack* obj) {
    QueueDestroy(&obj->q1);
    QueueDestroy(&obj->q2);
    free(obj);
    
}

3. 用栈实现队列。OJ链接

typedef struct {
    int* stk;
    int stkSize;
    int stkCapacity;
} Stack;

Stack* stackCreate(int cpacity) {
    Stack* ret = malloc(sizeof(Stack));
    ret->stk = malloc(sizeof(int) * cpacity);
    ret->stkSize = 0;
    ret->stkCapacity = cpacity;
    return ret;
}

void stackPush(Stack* obj, int x) {
    obj->stk[obj->stkSize++] = x;
}

void stackPop(Stack* obj) {
    obj->stkSize--;
}

int stackTop(Stack* obj) {
    return obj->stk[obj->stkSize - 1];
}

bool stackEmpty(Stack* obj) {
    return obj->stkSize == 0;
}

void stackFree(Stack* obj) {
    free(obj->stk);
}

typedef struct {
    Stack* inStack;
    Stack* outStack;
} MyQueue;

MyQueue* myQueueCreate() {
    MyQueue* ret = malloc(sizeof(MyQueue));
    ret->inStack = stackCreate(100);
    ret->outStack = stackCreate(100);
    return ret;
}

void in2out(MyQueue* obj) {
    while (!stackEmpty(obj->inStack)) {
        stackPush(obj->outStack, stackTop(obj->inStack));
        stackPop(obj->inStack);
    }
}

void myQueuePush(MyQueue* obj, int x) {
    stackPush(obj->inStack, x);
}

int myQueuePop(MyQueue* obj) {
    if (stackEmpty(obj->outStack)) {
        in2out(obj);
    }
    int x = stackTop(obj->outStack);
    stackPop(obj->outStack);
    return x;
}

int myQueuePeek(MyQueue* obj) {
    if (stackEmpty(obj->outStack)) {
        in2out(obj);
    }
    return stackTop(obj->outStack);
}

bool myQueueEmpty(MyQueue* obj) {
    return stackEmpty(obj->inStack) && stackEmpty(obj->outStack);
}

void myQueueFree(MyQueue* obj) {
    stackFree(obj->inStack);
    stackFree(obj->outStack);
}

4. 设计循环队列。OJ链接

typedef struct {
    int front;
    int rear;
    int capacity;
    int *elements;
} MyCircularQueue;

MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue *obj = (MyCircularQueue *)malloc(sizeof(MyCircularQueue));
    obj->capacity = k + 1;
    obj->rear = obj->front = 0;
    obj->elements = (int *)malloc(sizeof(int) * obj->capacity);
    return obj;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if ((obj->rear + 1) % obj->capacity == obj->front) {
        return false;
    }
    obj->elements[obj->rear] = value;
    obj->rear = (obj->rear + 1) % obj->capacity;
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if (obj->rear == obj->front) {
        return false;
    }
    obj->front = (obj->front + 1) % obj->capacity;
    return true;
}

int myCircularQueueFront(MyCircularQueue* obj) {
    if (obj->rear == obj->front) {
        return -1;
    }
    return obj->elements[obj->front];
}

int myCircularQueueRear(MyCircularQueue* obj) {
    if (obj->rear == obj->front) {
        return -1;
    }
    return obj->elements[(obj->rear - 1 + obj->capacity) % obj->capacity];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->rear == obj->front;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->rear + 1) % obj->capacity == obj->front;
}

void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->elements);
    free(obj);
}
Filex;
关注
  • 23
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 8
    评论
专栏目录
数据结构——栈与队列
Sweet_0115的博客
08-07 144
数据结构——栈与队列
数据结构----栈和队列阅读笔记
weixin_44932552的博客
06-08 274
认识数据结构 什么是数据结构？下面是维基百科的解释 数据结构是计算机存储、组织数据的方式 数据结构意味着接口或封装：一个数据结构可被视为两个函数之间的接口，或者是由数据类型联合组成的存储内容的访问方法封装 数组是最简单的内存数据结构，下面是常见的数据结构： 数组（Array） 栈（Stack） 队列（Queue） 链表（Linked List） 树（Tree） 图（Graph） 堆（Heap） 散列表（Hash） 下面来学习学习栈和队列… 1.栈数据结构 栈是一种线性数据结构，一个栈可以对数据按照顺序进行组
学习笔记：第三章 栈与队列
张小憨憨的博客
10-29 643
文章目录第三章 栈与队列第一部分 栈1. 栈的定义2. 栈的抽象数据类型3. 栈的顺序存储结构及实现（一）栈的定义方式：（1）栈的初始化：（2）栈的销毁：（3）栈的清空：（4）判断栈是否为空：（5）返回栈顶元素：（6）压栈：（6）出栈：（7）栈的元素个数：（8）栈元素从栈底依次输出：（二）栈的另一种方式定义方式：（1）栈的初始化：（2）栈的清空：（3）判断栈是否为空：（4）返回栈顶元素：（5）压栈：（6）出栈：（7）栈的元素个数：（8）栈元素从栈底依次输出：4. 两栈共享空间(1) 栈的初始化：(2) 栈
栈和队列--学习笔记
puffx2的博客
12-05 222
栈 栈的相关概念 常用、重要的数据结构 定义：限定插入和删除只能在表的端点（通常是表尾，称作栈顶）进行的线性表 逻辑结构：一对一关系，与普通线性表相同 存储结构：顺序栈或链栈均可，顺序栈更常见 运算规则：只能在栈顶运算 且访问结点依照后进先出（LIFO结构）原则 实现方式：编写入栈出栈函数 表尾a[n]端称为栈顶Top，表头a[1]端称为栈底Base 插入元素到栈顶（表尾）称为入栈（Push） 从栈顶删除最后一个元素称为出栈（Pop） 栈的抽象数据类型的类型定义 ADT Stack {
数据结构：栈和队列笔记
嵌入式学习记录站点
12-14 528
数据结构-栈和队列笔记整理
利用栈和队列实现迷宫
06-20
"利用栈和队列实现迷宫" 通过栈和队列两种不同的方法来实现迷宫问题。队列方法求出的迷宫路径是最短路径。迷宫问题是指在一个迷宫中找到从起点到终点的路径。这里我们使用栈和队列两种数据结构来解决这个问题。 栈...
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
Python实现栈和队列的简单操作方法示例
09-18
本篇文章将深入探讨Python中如何实现栈（Stack）和队列（Queue）这两种基础数据结构。 栈是一种后进先出（Last In, First Out, LIFO）的数据结构，常用于临时存储和快速访问数据。在Python中，由于列表（List）的...
栈和队列的基本操作
01-02
"栈和队列的基本操作" 栈和队列是计算机科学中两个基本的数据结构，它们的基本操作包括进栈、出栈、进队、出队等。栈是一种后进先出的数据结构，即最后一个入栈的元素将是第一个出栈的元素。队列是一种先进先出的...
栈和队列
01-08
当栈里没有元素时栈顶和栈底相等。只能从栈顶出入数据。 1.1栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的...
栈和队列笔记
qq_43627355的博客
11-28 226
一、特殊的线性表——栈 1.栈：限定仅在表尾进行插入和删除操作的线性表。 栈的特性：先进后出（first in last out）；允许删除和插入的一端称为栈顶，另一端称为栈底；插入包括入栈、进栈、压栈，删除包括出栈、弹栈。 注：栈只是对表插入和删除操作的位置进行了限制，并没有限定插入和删除操作进行的时间。 2.栈的抽象数据类型定义： DestroyStack 前置条件：栈...
栈和队列（笔记）
liuxiaojing20134422的专栏
10-31 463
栈和队列是操作受限的线性表，也是两种重要的抽象数据类型。 栈：  1、栈的逻辑结构：栈 是限定仅在表尾插入和删除操作的线性表。允许插入和删除的一端成为栈顶，另一端为栈底，不含任何数据元素的栈称为空栈。（后进先出） 2、栈的顺序存储结构及实现    （1）栈的初始化：初始化一个空栈只需将栈顶指针top置为-1.      （2）入栈操作：在栈中插入一个元素X只需将栈顶指针top加1，然后
栈和队列-笔记
#7的博客
03-08 180
1.栈是限定仅在表尾进行插入或删除操作的线性表。表尾端称为栈顶，表头端称为栈底。（栈又成为后进先出的线性表）2.非空栈中的栈顶指针始终在栈顶元素的下一个位置上。栈顶指针=栈底指针可作为栈空的标记。3.队列是一种先进先出的线性表，它只允许在表的一端进行插入，而在另一端删除元素。在队列中，允许插入的一端叫做队尾，允许删除的一端则称为队头。...
《数据结构与算法分析》学习笔记一：表、栈和队列
陈杰的专栏
05-16 1579
学习编程快一年了，之前一直想有所学的东西写一些实用的小程序，也花了不少时间看python这样的语言，但是几星期前看到的一篇博文《我的算法学习之路》，很有感触，于是下定决心趁早开始算法的学习，按照他文章中的推荐，我买了《数据结构与算法分析》c语言描述一书 (豆瓣链接) 。按照看书的进度把所得所想与大家分享。 一：表、栈和队列         抽象数据类型（abstract data type, 
栈与队列 — 学习笔记
qq_40114716的博客
03-10 1680
知识点总结： 栈和队列是STL（c++标准库）里面的两个数据结构。 c++标准库有三个版本： HP STL、P.J.Plauger STL、SGI STL。 在STL中，栈，队列不归类为容器，往往被归类为容器适配器。 栈的底层实现可以是 vector，deque，list 都可以，主要就是数组和链表的底层实现。 栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。 不像是set 或者map 提供迭代器iterator来.
栈与队列的操作（课堂笔记）
Hush
09-20 275
一、顺序栈 #include<iostream> using namespace std; #define MAXSIZE 100 typedef int Selemtype; typedef struct { Selemtype data[MAXSIZE]; int top; //栈顶 }SqStack; //顺序栈 int Push(SqStack* s, Sele...
栈和队列(笔记)
申小远的博客
08-20 246
栈先进后出的特性，也就是对于的插入和删除操作都是在栈顶进行的 队列先进先出，从队尾插入，对头弹出 一般情况下栈用顺序表来实现，因为栈的操作需要栈顶进行弹出操作，此时需要将栈顶指针指向上一个元素，如果用链表来做，则需要从头开始查找(单链表),使用循环链表也需要将指针循环一圈，此时的时间复杂度都是O(n)，也可以采用双向链表，但是双向链表实现起来并不简单(和顺序表相比)，而使用线性表来进行弹出操作...
数据结构笔记3：栈与队列
越开源越幸运
10-17 450
Table of Contents 栈 卡特兰数 队列 循环队列 双端队列 特殊矩阵的压缩存储 对称矩阵 三角矩阵 稀疏矩阵 因为觉得比较方便，之后的笔记都直接在书上做了，但是没有自己整理浓缩又总害怕不成体系，所以尽量放一些不太理解、记不住的 栈 卡特兰数 常见的问题：n个不同元素进栈，一共有多少种合法的出栈顺序？ 合法出栈数目==卡特兰数 凡是合法序列都遵循以下规律：即对于出栈序列中的每一个数字，在它后面的、比它小的所有数字，一定是按递减顺序排列的。 例如：有数字1 2
栈和队列学习笔记
不能说的秘密的博客
01-07 1125
栈和队列的比较简单，两种就是一个做了某些特殊限制的线性表。比如，去除线性表中可以通过通过索引访问元素的功能。去除通过某个元素得到索引位置的功能。去除普通线性表中可以在任意位置增删的功能，而只允许在线性表的某端进行，这样线性表就变成了特殊的线性表:栈，队列。从逻辑上看。栈和队列其实是有普通线性表发展而来，普通线性表增加一些特殊的限制就可以得到栈和队列了
数据结构栈和队列实验
最新发布
10-08
数据结构中的栈和队列是两种重要的数据结构。栈（Stack）是一种具有特殊限制的线性数据结构，它遵循LIFO（后进先出）原则，即最后进入的元素首先被访问或删除。栈有两个基本操作：压入（push）和弹出（pop）。队列...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Filex;

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

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

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

打赏作者

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

抵扣说明：

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

余额充值