数据结构~~栈和队列

最新推荐文章于 2024-05-23 17:36:25 发布
最新推荐文章于 2024-05-23 17:36:25 发布
阅读量945 收藏 30
点赞数 18
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78029441/article/details/138401038
版权

目录

一、基本概念

栈的概念

栈的实现 

队列的概念 

队列的实现 

二、栈

栈的结构

 三、队列

队列的结构

四、栈和队列的练习

有效的括号

设计循环队列

用栈实现队列

用队列实现栈

五、完整代码

栈

队列

六、总结

一、基本概念

在计算机科学中，数据结构是构建高效程序的基础。栈和队列是两种重要且常用的线性数据结构，它们在解决各种问题中发挥着关键作用。

栈的概念

栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端 称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。栈在许多场景中被广泛应用，比如函数调用的嵌套、表达式求值等。

栈的实现 

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

队列的概念 

队列：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有先进先出 FIFO(First In First Out) 入队列：进行插入操作的一端称为队尾 出队列：进行删除操作的一端称为队头。队列常用于任务调度、消息传递等情况。

队列的实现 

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

二、栈

栈的结构

typedef int STDataType;
typedef struct Stack
{
	STDataType* a;
	int top;//栈顶
	int capacity;//栈的总容量
}ST;

1.初始化栈

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

 2.摧毁栈

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

3.插入数据 

void STPush(ST* pst, STDataType x)
{
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc err");
			return;
		}
		pst->a = tmp;
		pst->capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}

4.删除数据 

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

5.获取栈顶元素

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

6.判断栈是否为空 

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

7.栈的元素个数

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

 三、队列

队列的结构

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}QNode;

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

1.初始化队列

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

2.摧毁队列

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;
}

3.插入队列

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc err");
		return;
	}
	newnode->data = x;
	newnode->next=NULL;
	if (pq->phead == NULL)
	{
		assert(pq->ptail == NULL);
		pq->phead = pq->ptail= newnode;
	}
	else
	{
		pq->ptail->next = newnode;
		pq->ptail = newnode;
	}
	pq->size++;
}

4.删除队列

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	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--;
}

5.队列头部

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->phead->data;
}

6.队列尾部

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}

7.查看队列的总长

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL
		&& pq->ptail == NULL;
}

8.判断队列为不为空

bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL
		&& pq->ptail == NULL;
}

四、栈和队列的练习

有效的括号

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

这题要先创建一个完整的栈，各个接口可以看下面标题五的完整代码

思路：

使用栈来解决这个问题。

遍历字符串中的每个字符：

• 如果遇到左括号（'('、'{'、'['），就将其入栈。

• 如果遇到右括号（')'、'}'、']'）：

• 检查栈是否为空，如果为空则说明没有对应的左括号，直接返回 false。

• 取出栈顶元素，看是否与当前右括号匹配，如果不匹配则返回 false。

• 遍历完整个字符串后，如果栈为空，说明所有括号都匹配成功，返回 true，否则返回 false。

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;
            }
            char top=STTop(&st);
            STPop(&st);
            if((top=='{'&&*s!='}')||(top=='('&&*s!=')')||(top=='['&&*s!=']'))
            {
                STDestroy(&st);
                return false;
            }
        }
        s++;
    }
    bool r =STEmpty(&st);
    STDestroy(&st);
    return r;
}

设计循环队列

设计你的循环队列实现。 循环队列是一种线性数据结构，其操作表现基于 FIFO（先进先出）原则并且队尾被连接在队首之后以形成一个循环。它也被称为“环形缓冲器”。

循环队列的一个好处是我们可以利用这个队列之前用过的空间。在一个普通队列里，一旦一个队列满了，我们就不能插入下一个元素，即使在队列前面仍有空间。但是使用循环队列，我们能使用这些空间去存储新的值。

你的实现应该支持如下操作：

  • MyCircularQueue(k): 构造器，设置队列长度为 k 。
  • Front: 从队首获取元素。如果队列为空，返回 -1 。
  • Rear: 获取队尾元素。如果队列为空，返回 -1 。
  • enQueue(value): 向循环队列插入一个元素。如果成功插入则返回真。
  • deQueue(): 从循环队列中删除一个元素。如果成功删除则返回真。
  • isEmpty(): 检查循环队列是否为空。
  • isFull(): 检查循环队列是否已满。

思路：

首先，我们需要定义一个类来表示循环队列。这个类需要包含以下几个成员变量：

1. 一个用于存储队列元素的数组。

2. 队列的头部索引和尾部索引。

3. 队列的最大容量。

对于构造器 myCircularQueueCreate(k)，我们初始化队列的最大容量为 k，并将头部和尾部索引都初始化为 -1，表示队列是空的。

对于 Front 函数，我们返回头部索引对应的元素，如果队列为空（即头部索引为 -1），则返回 -1。

对于 Rear 函数，我们返回尾部索引对应的元素，如果队列为空（即尾部索引为 -1），则返回 -1。

对于 enQueue(value) 函数，我们首先检查队列是否已满。如果已满，则返回 false。否则，我们将尾部索引向后移动一位（如果尾部索引已经到达数组末尾，则将其设置为 0），并将元素插入到尾部索引对应的位置，然后返回 true。

对于 deQueue() 函数，我们首先检查队列是否为空。如果为空，则返回 false。否则，我们将头部索引向后移动一位（如果头部索引已经到达数组末尾，则将其设置为 0），然后返回 true。

对于 Empty() 函数，我们只需要检查头部索引是否为 -1 即可。

对于 Full() 函数，我们检查尾部索引加 1 后是否等于头部索引（如果尾部索引已经到达数组末尾，则将其设置为 0），如果是，则表示队列已满，否则表示队列未满

typedef struct {
    int* a;
    int head;
    int tail;
    int k;
} MyCircularQueue;


MyCircularQueue* myCircularQueueCreate(int k) {
    MyCircularQueue* obj=(MyCircularQueue*)malloc(sizeof(MyCircularQueue));
    obj->a=(int*)malloc(sizeof(int)*(k+1));
    obj->head=0;
    obj->tail=0;
    obj->k=k;
    return obj;
}
bool myCircularQueueIsEmpty(MyCircularQueue* obj) {
    return obj->head==obj->tail;
}

bool myCircularQueueIsFull(MyCircularQueue* obj) {
    return (obj->tail+1)%(obj->k+1)==obj->head;
}

bool myCircularQueueEnQueue(MyCircularQueue* obj, int value) {
    if(myCircularQueueIsFull(obj))
      return false;
    obj->a[obj->tail]=value;
    obj->tail++;
    obj->tail%=(obj->k+1);
    return true;
}

bool myCircularQueueDeQueue(MyCircularQueue* obj) {
    if(myCircularQueueIsEmpty(obj))
       return false;
     ++obj->head;
     obj->head%=obj->k+1;
     return true;

}

int myCircularQueueFront(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj))
       return -1;
    else
       return obj->a[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) {
     if(myCircularQueueIsEmpty(obj))
       return -1;
    else
       return obj->a[(obj->tail+obj->k)%(obj->k+1)];
}


void myCircularQueueFree(MyCircularQueue* obj) {
    free(obj->a);
    free(obj);
}

用栈实现队列

请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：

实现 MyQueue 类：

  • void push(int x) 将元素 x 推到队列的末尾
  • int pop() 从队列的开头移除并返回元素
  • int peek() 返回队列开头的元素
  • boolean empty() 如果队列为空，返回 true ；否则，返回 false

说明：

  • 你 只能 使用标准的栈操作 —— 也就是只有 push to top, peek/pop from top, size, 和 is empty 操作是合法的。
  • 你所使用的语言也许不支持栈。你可以使用 list 或者 deque（双端队列）来模拟一个栈，只要是标准的栈操作即可。

这题要先创建一个完整的栈，各个接口可以看下面标题五的完整代码 

思路：

我们可以使用两个栈，一个用于输入（pustst），一个用于输出（popst）。

当进行 push 操作时，直接将元素压入 popst。

当进行 pop 或 peek 操作时，如果 outStack 为空，则将 pustst 中的所有元素依次弹出并压入 popst，然后从 popst进行 pop 或 peek。

这样就能模拟出先入先出的队列行为。

typedef struct {
    ST popst;
    ST pushst;
} MyQueue;


MyQueue* myQueueCreate() {
    MyQueue* obj=(MyQueue*)malloc(sizeof(MyQueue));
    STInit(&obj->popst);
    STInit(&obj->pushst);
    return obj;
    
}

void myQueuePush(MyQueue* obj, int x) {
    STPush(&obj->pushst,x);
}

int myQueuePop(MyQueue* obj) {
    int fon = myQueuePeek(obj);
    STPop(&obj->popst);
    return fon;
}

int myQueuePeek(MyQueue* obj) {
    if(STEmpty(&obj->popst))
    {
        while(!STEmpty(&obj->pushst))
        {
            int top=STTop(&obj->pushst);
            STPush(&obj->popst,top);
            STPop(&obj->pushst);
        }
    }
    return STTop(&obj->popst);
}

bool myQueueEmpty(MyQueue* obj) {
    return STEmpty(&obj->popst)
       &&  STEmpty(&obj->pushst);
}

void myQueueFree(MyQueue* obj) {
    //STDestroy(&obj->popst);
    STDestroy(&obj->pushst);
    STDestroy(&obj->popst);
    free(obj);
}

用队列实现栈

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

实现 MyStack 类：

  • void push(int x) 将元素 x 压入栈顶。
  • int pop() 移除并返回栈顶元素。
  • int top() 返回栈顶元素。
  • boolean empty() 如果栈是空的，返回 true ；否则，返回 false 。

注意：

  • 你只能使用队列的标准操作 —— 也就是 push to back、peek/pop from front、size 和 is empty 这些操作。
  • 你所使用的语言也许不支持队列。 你可以使用 list （列表）或者 deque（双端队列）来模拟一个队列 , 只要是标准的队列操作即可。

这题要先创建一个完整的队列，各个接口可以看下面标题五的完整代码

思路：

当进行 push 操作时，将元素添加到一个非空队列中。

当进行 pop 或 top 操作时，将非空队列中的元素除最后一个外都依次移到另一个空队列中，此时非空队列中的最后一个元素就是栈顶元素，对其进行相应操作后，交换两个队列的角色。

通过这样不断在两个队列之间转移元素来模拟栈的后进先出特性。

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* noempty=&obj->q2;
    if(!QueueEmpty(&obj->q1))
    {
        empty=&obj->q2;
        noempty=&obj->q1;
    }
    while(QueueSize(noempty)>1)
    {
        QueuePush(empty,QueueFront(noempty));
        QueuePop(noempty);
    }
    int top =QueueFront(noempty);
    QueuePop(noempty);
    return top;
}

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->q2);
    QueueDestroy(&obj->q1);
    free(obj);
}

五、完整代码

栈

Stack.h

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

typedef int 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);//栈的元素 个数

Stack.c 

#include"Stack.h"
void STInit(ST* pst)
{
	assert(pst);
	pst->a = NULL;
	pst->top = 0;
	pst->capacity = 0;
}
void STDestroy(ST* pst)
{
	assert(pst);
	free(pst->a);
	pst->a = NULL;
	pst->capacity = pst->top = 0;
}
void STPush(ST* pst, STDataType x)
{
	if (pst->top == pst->capacity)
	{
		int newCapacity = pst->capacity == 0 ? 4 : pst->capacity * 2;
		STDataType* tmp = (STDataType*)realloc(pst->a, newCapacity * sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc err");
			return;
		}
		pst->a = tmp;
		pst->capacity = newCapacity;
	}
	pst->a[pst->top] = x;
	pst->top++;
}
void STPop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	pst->top--;
}
STDataType STTop(ST* pst)
{
	assert(pst);
	assert(!STEmpty(pst));
	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;
}

队列

Queue.h

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

typedef int QDataType;
typedef struct QueueNode
{
	QDataType data;
	struct QueueNode* next;
}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);//判断队列为不为空

Queue.c

#include"Queue.h"
void QueueInit(Queue* pq)
{
	assert(pq);
	pq->phead = NULL;
	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 err");
		return;
	}
	newnode->data = x;
	newnode->next=NULL;
	if (pq->phead == NULL)
	{
		assert(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(!QueueEmpty(pq));
	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(!QueueEmpty(pq));
	return pq->phead->data;
}
QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(!QueueEmpty(pq));
	return pq->ptail->data;
}
int QueueSize(Queue* pq)
{
	assert(pq);
	return pq->size;
}
bool QueueEmpty(Queue* pq)
{
	assert(pq);
	return pq->phead == NULL
		&& pq->ptail == NULL;
}

六、总结

栈（Stack）

1. 后进先出原则。

2. 主要操作包括入栈（push）和出栈（pop）。

3. 常用于函数调用、表达式求值、括号匹配等场景。

队列（Queue）

1. 先进先出原则。

2. 主要操作包括入队（enqueue）和出队（dequeue）。

3. 常用于任务调度、排队系统、广度优先搜索等。

两者都是基本的数据结构，具有不同的特点和适用场景，在程序设计中发挥着重要作用。

TU^
关注
  • 18
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
数据结构栈和队列试题及答案
11-26
栈和队列考试题 复习 栈和队列考试题 复习栈和队列考试题 复习
Python 实现数据结构中的的栈队列
09-19
主要介绍了Python 实现数据结构中的的栈，队列,本文给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
数据结构：栈和队列(Stack & Queue)【详解】
热门推荐
UniqueUnit的博客
02-19 21万+
栈和队列知识框架 栈 一、栈的基本概念 1、栈的定义 栈（Stack）：是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。 栈顶（Top）：线性表允许进行插入删除的那一端。 栈底（Bottom）：固定的，不允许进行插入和删除的另一端。 空栈：不含任何元素的空表。 栈又称为先进先出（Last In First Out）的线性表，简称LIFO结构 2、栈的基本操作 InitStack(&S)：初始化一个空栈S。 StackEmpty(S)：
数据结构与算法——栈和队列
小田是个程序员的博客欢迎你的到来呀~
06-25 1万+
栈和队列是两种重要的线性结构，本篇文章详细总结了数据结构与算法中栈和队列的终点知识，并且结合代码片段实现其基本操作，干货满满，每一句话都是重点，希望能给更多的小伙伴在学习数据结构与算法时带来一定帮助...
数据结构~07.栈和队列的基本概念
qq_41424688的博客
07-28 3万+
数据结构学习~07.栈和队列的基本概念 本文是上一篇文章的后续,详情点击该链接~ 栈的定义:        栈是一种只能在一端进行插入或删除的线性表。其中,允许插入或删除的一端为栈顶(TOP)。栈顶由一个称为栈顶指针的位置指示器来指示。它是动态变化的 ...
Java数据结构之栈和队列
fear_wolf的博客
10-24 1014
我们可以从集合那一节的图中看出，Stack继承了Vector，Vector和ArrayList类似，都是动态的顺序表，不同的是Vector是线程安全的。我们可以采用头插法来入栈，每次出栈时删除的也是头节点，时间复杂度也是O（1），但仍没有顺序栈方便，毕竟顺序栈不用修改指向。：只允许在一端进行插入数据操作，在另一端进行删除数据操作的特殊线性表，队列具有。，队不为空时，rear都是front之后，随着入队出队的操作，最终。：栈的插入操作，叫做进栈/压栈/入栈，入数据在栈顶。
数据结构 ~ 栈、队列
DGogoing的博客
07-17 2260
栈、队列
数据结构与算法——栈和队列定义和特点
weixin_68773927的博客
10-27 3591
栈（stack）是一个特殊的线性表是限定仅在一端（通常是尾部）运行插入和删除操作的线性表又称为先进先出的线性表简称 LIFO 结构 9（Last In First out）
数据结构实验--栈和队列操作
跳跳糖°的博客
04-17 3309
数据结构实验–顺序栈的操作 文章目录数据结构实验--顺序栈的操作一、实验要求二、实验核心算法二、实验代码示例 一、实验要求 编程实现栈的以下基本操作：建栈，取栈顶元素，入栈，出栈，显示顺序栈元素 二、实验核心算法 （1）定义顺序栈的存储结构，用base表示栈底指针，top表示栈顶指针，stacksize表示栈的容量 typedef struct { SElemType *base; //栈底指针 SElemType *top; //栈顶指针 int s
数据结构----栈和队列
喜欢编写一些小程序的科班菜鸟，但是由于准备考研，博客不能及时更新了，不好意思！
05-19 1400
栈篇 1.1栈 栈，线性表的一种特殊的存储结构。与学习过的线性表的不同之处在于栈只能从表的固定一端对数据进行插入和删除操作，另一端是封死的。由于栈只有一边开口存取数据，称开口的那一端为“栈顶”，封死的那一端为“栈底”（类似于盛水的木桶，从哪进去的最后还得从哪出来）。 1.2.栈操作数据元素的两种动作： 数据元素用栈的数据结构存储起来，称为“入栈”，也叫“压栈”。 数据元素由于某种原因需要从栈结构中提取出来，称为“出栈”，也叫“弹栈”。 注意：栈遵循先进后出原则 1.3.栈的表示方式 既然栈
数据结构实验报告—栈和队列
VLOKL的博客
03-31 3158
数据结构实验报告，栈，队列，C语言
C++数据结构实验二：栈与队列的应用
03-31
3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和队列在两种存储结构上的各种基本操作的实现算法。 4.将任意十进制数转换为三种...
数据结构中栈和队列思想的停车场管理系统
02-25
基于c语言数据结构中栈和队列思想的简单停车场管理系统，以栈模拟停车场，以队列模拟车场外的便道，按照从终端读入的输入数据序列进行模拟管理。每一组输入数据包括三个数据项：汽车“到达”或“离去”信息、汽车...
数据结构栈和队列详解.zip
04-03
栈和队列是两种非常基础且重要的数据结构，它们在计算机科学和软件开发中都有着广泛的应用。下面我将详细解释这两种数据结构。 栈（Stack） 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。这...
C-数据结构-单向循环链表
aqiangdeba的博客
05-23 251
单向无头结点一定要注意传参 一般是二维指针问题 非常容易出错。
[Collection与数据结构] Map与Set(二):哈希表
2301_80050796的博客
05-20 872
🏵️热门专栏:🍕 Collection与数据结构 (91平均质量分)🧀Java EE(94平均质量分)🍭MySql数据库(93平均质量分)🍬算法(97平均质量分)
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
qq_50891451的博客
05-22 505
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
数据结构---树，二叉树的简单概念介绍、堆和堆排序
最新发布
2301_80028974的博客
05-23 594
在我们将堆之前，我们先来了解一下我们的树。我们的堆是属于树里面的一种，树是一种非线性结构，是，也就是我们的一个节点可能有多个后继节点，当然也可以只有一个或者没有。，我们把它叫做树是因为他的结构和一颗倒挂的数很像。
数据结构复习队列和栈
07-30
数据结构中的队列和栈是两种常见的数据结构。队列是一种先进先出（FIFO）的数据结构，而栈是一种后进先出（LIFO）的数据结构。 队列的基本概念包括定义和常见基本操作。队列可以使用顺序存储结构或链式存储结构来实现。顺序队列使用数组来存储元素，而循环队列是一种特殊的顺序队列，可以循环利用数组空间。链队列是一种使用链表实现的队列，它具有队头指针和队尾指针。队列的常见基本操作包括初始化、判队空、求队列长度、入队和出队等操作。 栈的基本概念包括定义和常见基本操作。栈可以使用顺序存储结构或链式存储结构来实现。顺序栈使用数组来存储元素，而链栈是一种使用链表实现的栈，它具有栈顶指针和元素个数。栈的常见基本操作包括初始化、判栈空、进栈、出栈和读栈顶元素等操作。 队列和栈在数据结构中有着广泛的应用。例如，队列可以用于实现广度优先搜索算法，栈可以用于实现深度优先搜索算法。此外，栈还可以用于递归算法的实现，而队列可以用于模拟实际生活中的排队场景。 综上所述，队列和栈是数据结构中常见的两种数据结构，它们分别具有不同的特点和应用场景。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值