栈和队列(c语言实现)

原创 已于 2024-12-01 20:15:33 修改 · 1.1k 阅读 · 22 ·
本内容遵循CC 4.0 BY-SA版权协议
标签
#数据结构 #c语言
于 2024-07-03 21:37:48 首次发布

  作战地图如下：

   

栈：

    一，栈是啥？？？：

栈是一种线性(每个数据的相对位置前后在空间或逻辑上连续)的数据结构，主要涉及压栈和出栈两种操作。压栈是指向一组数据的尾部添加新数据，出栈是指从一组数据的尾部移除数据。数据"后进先出"

    二，模拟实现：

由于栈仅涉及对尾部的操作，因此选择用数组(其实链表也可)实现。

#include<stdio.h>
#include<stdlib.h> //使用realloc时要包含
#include<stdbool.h> //使用bool类型时要包含
#include<assert.h> //使用assert断言时要包含

typedef int datatype; //方便后续更改类型

typedef struct stack
{
	datatype *arr;
	int top;
	int capacity;
}stack;

//初始化栈
void InitStack(stack *p)
{
	assert(p);
	p->capacity = 0;
	p->top = -1;
	p->arr = NULL;
}

//入栈
void PushStack(stack *p, datatype data)
{
{
 	assert(p);	
	if (p->capacity == (p->top + 1))
	{
		int newcapacity = p->capacity == 0 ? 4 : 2* p->capacity;
		datatype* newp = (datatype*)realloc(p->arr, newcapacity* sizeof(datatype));
		if (newp == NULL)
		{
			perror("realloc failed!");
			return;
		}
		p->arr = newp;
		p->capacity = newcapacity;
	}
	p->arr[++(p->top)] = data;
}

//出栈
void PopStack(stack *p)
{
	assert(p);
	assert(p->top >= 0);
	--(p->top); //访问数组元素时使用top作为下标，减少top即可
}

//获取栈顶元素
datatype Stacktop(stack *p)
{
	assert(p);
	assert(p->top >= 0);
	return p->arr[p->top];
}

//获取栈中有效元素个数
int Stacksize(stack *p)
{
	assert(p);
	assert(p->top >= 0);
	return p->top+1;
}

//检查栈为空
bool Stackempty(stack* p)
{
	assert(p);
	return p->top==-1;
}

//销毁栈
void DestoryStack(stack* p)
{
	assert(p);
	free(p->arr);
	p->arr = NULL;
}

三，模拟实现的细节补充：

   ① top的初始值：由于使用数组实现，第一个元素下标为0，而我们对习惯把对整形时初始化为0，这样就会出现歧义，如下图：

解决方法有两种：

   ② 保留功能单一，代码量少的函数：例如获取栈顶元素的函数，看似写成函数是多此一举，其实至少要考虑一下两点

  1. 如果在函数的声明和定义分离式，使用者不知明晰top的真实含义(即top是指向栈顶元素位置还是指向栈顶元素的下一个位置的下标)，就会有越界访问的风险。
  2. 写成函数是可以添加必要的检查代码(如assert断言)，可以防止诸如对空栈进行删除的操作

四、应用：20. 有效的括号 - 力扣（LeetCode）

栈接口的实现…………

bool isValid(char* s) 
{
    stack st;
    InitStack(&st);
    while(*s) //当字符串的走到\0是结束
    {
        if(*s == '(' || *s == '{' || *s == '[') //遇到左括号时入栈
        {
            PushStack(&st,*s);
        }
        else
        {
            if(Stackempty(&st))
            {
                return false; //处理字符串只有一个左括号的情况
            }
            datatype top_value = Stacktop(&st);
            PopStack(&st);
            if(top_value == '(' && *s != ')'
            || top_value == '{' && *s != '}'
            || top_value == '[' && *s != ']')
            {
                return false;
            }
        }
        s++;
    }
    bool ret = Stackempty(&st); //处理字符串只有一个左括号的情况
    return ret;
}

队列：

    一、队列是啥？？？：

队列是一种线性的数据结构(每个数据的相对位置前后在空间或逻辑上连续)，主要操作涉及入队列和出队列。入队列和栈类似，是在队尾添加数据，而出队列是在队头移除数据，正因如此才造成了队列有别于栈的特性----"先进先出"。

    二、模拟实现

由于队列删除数据涉及第一个元素的修改，使用数组实现的话涉及挪动后面的元素，效率低下。所以用单链表（单向不带头不循环）实现(用双向链表会多消耗一个指针变量的内存，不推荐)。

typedef int datatype;

typedef struct queuenode
{
	datatype data;
	struct queuenode *next;
}qnode;

typedef struct ftnode
{
	qnode* phead;
	qnode* ptail;
	int size;
}ftnode;

// 初始化队列
void InitQueue(ftnode* p)
{
    assert(p);
    p->phead = p->ptail = NULL;
    p->size = 0;
}

//销毁
void Destory(ftnode * p)
{
    assert(p);
    qnode* cur = p->phead;
    while (cur)
    {
        qnode* next = cur->next;
        free(cur);
        cur = next;
    }
    p->phead = p->ptail = NULL;
    p->size = 0;
}

//队尾插入
void Push(ftnode* p,datatype x)
{
    assert(p);
    // 创建新节点
    qnode* newnode = (qnode*)malloc(sizeof(qnode));
    if (!newnode)
    {
        perror("malloc failed!!!");
        return;
    }
    newnode->data = x;
    newnode->next = NULL;

    if (!(p->phead))
    {
        p->phead = p->ptail = newnode;
    }
    else
    {
        p->ptail->next = newnode;
        p->ptail = newnode;
    }
    p->size++;
}

//队头删除
void Pop(ftnode *p)
{
    assert(p);
    if (p->size == 0) // 检查队列是否为空
    {
        fprintf(stderr, "Queue underflow!\n");
        return;
    }
    qnode* next = p->phead->next;
    free(p->phead);
    p->phead = next;
    if (p->phead == NULL) // 如果队列为空，更新 ptail
    {
        p->ptail = NULL;
    }
    p->size--;
}

//获取队头数据
datatype DataHead(ftnode *p)
{
    assert(p);
    return p->phead->data;
}

//获取队尾数据
datatype DataTail(ftnode* p)
{
    assert(p);
    return p->ptail->data;
}

三、模拟实现的细节补充：

    ①巧妙地避开二级指针：由于链表通过next指针寻找相邻节点的特性，每个节点都要定义为一个指针，声明和定义头结点时也是如此，因此进行函数传参时要使用二级指针来修改外部的头结点。这样不仅不易理解而且实际操作起来也比较繁琐 (二级指针同样使我难受)，为了解决这个问题，在定义好节点的结构体后，再把特殊的节点(头结点phead和尾结点ptail)以指针的形式用另一个结构体定义好，这样只用通过这个结构体变量的指针就能对实际的节点进行修改了(因为这时直接就能访问到地址，从而对修改节点)。

    ②更方便的获取元素个数：第一点中提到了把特殊节点进行封装的其中一个好处，不仅如此，因为phead和ptail这两个指针同时也代表了队列所关系的队头和队尾元素，所以每次插入或删除都会对他们有影响。那么在这个结构体中再加入一个size来表示元素的个数就会很方便,插入时顺便让size++,删除时顺便让size--，还省去了写一个计算元素个数的函数，何乐而不为？

四、622. 设计循环队列 - 力扣（LeetCode）

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

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

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

bool myCircularQueueIsEmpty(MyCircularQueue* obj);
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;
    }
    return obj->arr[obj->head];
}

int myCircularQueueRear(MyCircularQueue* obj) 
{
    if(myCircularQueueIsEmpty(obj))
    {
        return -1;
    }
    else
    return obj->tail == 0 ? obj->arr[obj->k] : obj->arr[obj->tail-1];
     //return obj->arr[(obj->tail - 1 + obj->k + 1) % (obj->k + 1)];
}

bool myCircularQueueIsEmpty(MyCircularQueue* obj) 
{
    return obj->head == obj->tail;
}

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

void myCircularQueueFree(MyCircularQueue* obj) 
{
    free(obj->arr);
    obj->arr = NULL;
    free(obj);
    obj = NULL;
}

“栈和队列的相互转换”：

一、232. 用栈实现队列 - 力扣（LeetCode）   

 ​​​​    ①题意：使用两个栈实现一个“先进先出”的队列，使之能实现队头删除、队尾插入、获取队头元素以及队列判空等4个基本功能。

     ②思路分析：栈的队尾插入和队列类似，而判空则是两个栈同为空即可，并不特殊，所以着重分析队头删除和获取队头元素。如下图：

    

栈声明和接口接口 略......

typedef struct 
{
    stack *push_stack; //专门用于入数据
    stack *pop_stack; ///专门用于出数据
} MyQueue;


MyQueue* myQueueCreate() 
{
    MyQueue* obj = (MyQueue*)malloc(sizeof(MyQueue));
     obj->push_stack = (stack*)malloc(sizeof(stack));
     obj->pop_stack = (stack*)malloc(sizeof(stack));
    InitStack(obj->push_stack);
    InitStack(obj->pop_stack);
    return obj;
}

void myQueuePush(MyQueue* obj, int x) 
{
     PushStack(obj->push_stack,x);
}

int myQueuePeek(MyQueue* obj) 
{
   if(Stackempty(obj->pop_stack)) 
   {
     while(!Stackempty(obj->push_stack))
     {
        int mid = Stacktop(obj->push_stack);
        PopStack(obj->push_stack);
        PushStack(obj->pop_stack,mid);
     }
   }
  return Stacktop(obj->pop_stack);
}

int myQueuePop(MyQueue* obj) 
{
    int ret = myQueuePeek(obj);
   
    PopStack(obj->pop_stack);
   
    return ret;
}

bool myQueueEmpty(MyQueue* obj) 
{
    return Stackempty(obj->pop_stack) && Stackempty(obj->push_stack);
}

void myQueueFree(MyQueue* obj) 
{
   InitStack(obj->push_stack);
   InitStack(obj->pop_stack);
   free(obj);
   obj = NULL;
}

二、225. 用队列实现栈 - 力扣（LeetCode）

    ①题意：使用两个队列实现一个数据"先进后出"的栈，实现入栈、获取栈顶元素、删除栈顶元素以及判断是否为空栈等4个功能。

    ②思路分析：入栈只需和队列一样在尾部插入即可，两个队列都为空则栈为空。要着重分析获取栈顶元素和删除栈顶元素，如下图：

C语言实现栈和队列
Sun_student的博客
01-08 3253
一、栈（原理：FILO||LIFO）        实现思想：利用静态顺序表实现栈                      1.定义结构体，包含值和数组还有栈顶成员变量记录栈内元素个数（栈主要就是对栈顶元素的操作）                      2.初始化、销毁（比较简单看代码理解）                      3.增操作：先判断栈是否已满，再在栈顶进行添加；（...
c语言 栈和队列的实现
编程爱好者的博客
08-14 6900
前提知识 顺序表 优点：可以随机访问，cpu高速缓存利用率高，不涉及（较少）进行插入和删除操作，应该使用顺序表 一般而言，我们使用顺序表（数组）的形式建立 栈这一数据结构。   栈（stack）又名堆栈，它是一种运算受限的线性表。其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。 其特点是先进后出，模仿c++stl的stack和queue，我...
栈和队列--C语言实现
weixin_56605381的博客
04-28 301
快速了解栈和队列的属性和如何实现
【数据结构】栈和队列（c语言实现）（附源码）
2301_80955819的博客
08-04 1998
栈只能从同一端进行插入、删除操作，遵从“先进后出”原则；而队列只能从一端插入、另一端删除，遵从“先进先出”原则。栈和队列在一些场景的实用性很高，例如二叉树的层序遍历、快速排序的非递归实现等。
【栈和队列】C语言简单应用 ⌊栈和队列互相实现，循环队列⌉
qq_62852431的博客
04-19 2277
栈和队列简单应用
数据结构 - 栈和队列（C语言实现）
C橘子
04-13 7967
一. 栈 栈的定义  栈（Stack）是一种只能在一端进行插入或删除操作的线性表。                     图一 栈的示意图 顺序栈的基本操作   初始化 void InitStack(Stack *S){ //初始化顺序栈即使栈顶指针为-1 S->Top = -1; }   栈判空 int StackEmpty(Stack *S) { //栈判空函数...
Python 优雅解析 Excel：从原生行列到强类型对象的三层数据结构演进
asdzx67的博客
06-15 295
对于数据结构固定、业务逻辑复杂的 Excel 场景，字典结构的弱类型特性会带来类型混乱、无代码提示、无法封装业务逻辑等问题。定义业务实体类，将每行 Excel 数据映射为实体对象，实现强类型约束、自动代码补全、自定义数据校验和业务方法封装。从「二维列表数字索引」到「字典语义取值」，再到「自定义对象强类型封装」，三层数据结构的迭代，本质是代码从「机器思维」向「业务思维」的升级。简单场景无需过度设计，通用场景优先字典列表，工程化复杂场景首选自定义实体对象。
多线程编程（一）
m0_62591054的博客
06-16 191
编译时：需加上 -lpthread，链接上对应的线程支持库。
哈夫曼树
Queenie_Charlie 的博客
06-13 268
实际上，哈夫曼算法的实现与实际问题所采用的存储结构有关。现假设用数组F来存储哈夫曼树，其中第i个数组元素F[i]是哈夫曼树中的一个结点，其地址为i，有3个域，Data域存放该结点的权值，lChild域和rChild域分别存放该结点左、右子树的根结点的地址（下标）。在以后每步构造一棵新二叉树时，都需要对森林中所有二叉树的根结点进行排序，因此可用数组a作为排序暂存空间，其中第i个数组元素a[i]是森林F中第i棵二叉树的根结点，有2个域，Data是根结点所对应的权值，Addr是根结点在F中的地址（下标）。
算法与数据结构---二叉搜索树(BST)
最新发布
MzKyle的博客
06-17 1157
二叉搜索树（BST）是一种基于二叉树的有序数据结构，核心特性是左子树节点值小于根节点，右子树节点值大于根节点。本文系统介绍了BST的核心概念与操作实现： 基本定义：BST通过"左小右大"的规则维护有序性，所有操作复杂度为O(h)，h为树高。平衡时h≈log₂n，退化为链表时h=n。 关键操作： 查找：根据值比较选择左右子树路径 插入：在适当位置创建新节点 删除：处理三种情况（无子节点、单子节点、双子节点），最复杂的是用中序前驱/后继替代被删节点 重要特性：中序遍历BST会得到有序序列，这是BST的核心性质。
Python 五大核心数据结构完全指南：列表(List)、字符串(String)、元组(Tuple)、集合(Set)、字典(Dictionary)
小赵的博客
06-15 288
本文系统梳理了 Python 五大核心数据结构——列表、字符串、元组、集合、字典，涵盖各自定义特点、索引切片规则及常用操作方法。列表有序可变，字符串不可变但支持索引，元组不可修改，集合无序去重，字典存储键值对。通过对比表格总结适用场景，助力读者稳固编程基础，提升数据处理能力。
数据结构之链表OJ题(下)
2503_92261635的博客
06-12 673
本文介绍了三个链表相关算法题解：1) 141题使用快慢指针判断链表是否有环；2) 142题在判断有环基础上找到环入口，通过计算两段链表长度差定位交点；3) LCR026题重排链表，先找到中点，逆置后半段，再交替插入前半段。三题均涉及快慢指针技巧，并综合运用了链表基本操作，展现了处理链表问题的典型思路。
[数据结构]细说0xFFFFFFFFL
iningwei的博客
06-12 263
的高32位自动补0，低32位为全1。因此，它被正确解释为一个巨大的正数，而不是负数。主要用于将有符号的32位整数转换为无符号的64位长整数，以保留其原始位模式代表的正值。是有符号的32位整数，最高位为符号位，全1的二进制补码表示 -1。是一个编程中常见的十六进制长整型（long）字面量。在 Java、C等强类型语言中，如果不加后缀，为什么需要加 “L”？是64位有符号整数，
从kubectl学Visitor模式：如何优雅处理多态数据结构的遍历
java_cj的专栏
06-15 267
kubectl的Visitor模式解析 本文通过配置同步工具开发中的实际问题，引出了Visitor设计模式的应用场景。该模式的核心思想是将数据结构与操作逻辑解耦，使新增操作无需修改原有代码。 在kubectl源码中，Visitor模式被巧妙用于处理多种数据源（文件/HTTP/Git等）： 统一接口：定义Visitor接口和Info数据结构，屏蔽底层差异 多态实现：FileVisitor处理文件，URLVisitor处理HTTP请求，统一委托给StreamVisitor解析 扩展性：新增数据源只需实现Visi
【C++】数据结构之图的基本概念
L_0907的博客
06-17 255
本文系统介绍了并查集和图两种重要数据结构。并查集部分详细阐述了其基本概念、逻辑结构（森林表示）与物理存储（数组实现），重点讲解了路径压缩和按秩合并两种优化策略，并通过省份数量、等式方程等LeetCode题目展示了实际应用。图结构部分明确定义按秩合并顶点、边、有向/无向图等核心概念，比较了邻接矩阵和邻接表两种存储方式的优劣，给出了完整的C++实现代码。全文通过理论讲解结合代码实践，为后续学习图的遍历、最小生成树等算法奠定了坚实基础。
数据结构 图（概念篇）
youren_7715的博客
06-14 732
图（Graph）是由顶点（Vertex）边（Edge）组成的非线性数据结构，用于表示实体（顶点）及其关系（边）。数学上表示为 ( G = (V, E) )，其中 ( V ) 是顶点集合，( E ) 是边集合。
C/C++ 数据结构（九）深搜广搜
2301_80252792的博客
06-17 548
本文系统介绍了迷宫寻路算法的核心实现方法。重点分析了深度优先搜索(DFS)和广度优先搜索(BFS)两种算法，分别基于栈和队列实现。DFS采用"一条路走到底"的策略，适用于快速找到可行路径；BFS通过分层扩散确保找到最短路径。文章详细展示了两种算法的代码实现，包括迷宫表示、移动方向处理、越界判断等关键环节。同时探讨了路径记录、拾取所有金币等拓展场景，并比较了两种算法在时间复杂度、空间复杂度和适用场景上的差异。最后简要提及了A*算法等进阶内容，为游戏开发和路径规划提供了实用指导。
C/C++ 数据结构（四）链表与STL容器
2301_80252792的博客
06-13 534
本文系统梳理了C++链表与STL容器的核心知识点：1. 链表设计：对比带头/不带头结点的实现差异，；2. STL容器：详解vector/list/forward_list的底层结构、特性差异及选型策略；3. 迭代器机制：阐释其指针封装本质、遍历方式及不同容器的失效规则；4. 关键组件：包括仿函数实现自定义排序、模板类的类型约束要求、C++11的emplace优化等；5. 实践要求：提出手写带头尾结点的双向链表模板类，需封装迭代器并处理深拷贝问题。
数据结构-栈和队列
2301_79176091的博客
06-14 265
本文介绍了栈和队列这两种线性表结构的定义、实现及应用。栈遵循后进先出(LIFO)原则，可使用数组或链表实现，动态栈通过扩容支持高效操作。队列遵循先进先出(FIFO)原则，通常用链表实现更优，包含初始化、入队、出队等基本操作。此外还介绍了循环队列的概念及实现方法，包括判空判满逻辑和环形结构处理。最后提供了栈和队列的常见面试题及概念选择题，涵盖括号匹配、相互实现等典型问题。文章通过代码示例详细说明了各种操作的实现原理，包括动态扩容、环形索引计算等关键技术点。
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值