栈 C语言

已于 2024-05-28 19:02:01 修改
阅读量393 收藏 7
点赞数 5
文章标签： java 数据结构 开发语言
于 2024-05-28 17:53:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/WG_17/article/details/139273100
版权

 1.栈的结构和定义


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

栈顶（Top）：线性表允许进行插入删除的那一端。
栈底（Bottom）：固定的，不允许进行插入和删除的另一端。
空栈：不含任何元素的空表栈的实现

2. 栈的基本操作：

 

//数据元素的定义
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); 

2.1初始化：

// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);//栈不为空
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

2.2入栈

// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//若ps为NULL，则不成立
	assert(ps);
	//如果top==capacity的话，则需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果capacity为0的话 则给它初始化成4，如果不为0的话，就扩成capacity的2倍
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)//开辟空间失败
		{
			perror("realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}

2.3出栈

// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);//若栈为空，则出不了元素
	assert(ps->top != 0);//栈内元素个数不为0
	ps->top--;
}

2.4获取栈顶元素

/ 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];//top指向栈顶元素后一个
}

2.5获取栈内有效元素个数

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

2.6检验栈是否为空

// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;//如果等于0的话为空返回0 显示错误，返回其他>0的数则是为真
}

2.7销毁栈

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

综合：

#include "stack.h"
// 初始化栈 
void StackInit(Stack* ps)
{
	assert(ps);
	s->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//若ps为NULL，则不成立
	assert(ps);
	//如果top==capacity的话，则需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果capacity为0的话 则给它初始化成4，如果不为0的话，就扩成capacity的2倍
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)//开辟空间失败
		{
			perror("realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);//若栈为空，则出不了元素
	assert(ps->top != 0);
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;//如果等于0的话为空返回0 显示错误，返回其他>0的数则是为真
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}

3.栈的实际运用

（1）括号匹配问题：

typedef char 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 StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//若ps为NULL，则不成立
	assert(ps);
	//如果top==capacity的话，则需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 1 : ps->capacity * 2;//如果capacity为0的话 则给它初始化成4，如果不为0的话，就扩成capacity的2倍
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)//开辟空间失败
		{
			perror("realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);//若栈为空，则出不了元素
	assert(ps->top > 0);
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;//如果等于0的话为空返回0 显示错误，返回其他>0的数则是为真
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
bool isValid(char* s) {
    Stack l;//定义
    StackInit(&l);//初始化
    while(*s)
    {
        if((*s == '(')||(*s=='[')||(*s=='{'))//入栈
        {
            StackPush(&l,*s);
        }else
        {
           if(StackEmpty(&l))
            {
                StackDestroy(&l);
                return false;
            }
            char tmp = *s;
            char top = StackTop(&l);
            StackPop(&l);
           if((top == '('&&*s!=')')
           ||(top == '['&&*s!=']')
           ||(top == '{'&&*s!='}'))
            {
                StackDestroy(&l);
                return false;
            }
        }
        s++;
    }
    bool ret = StackEmpty(&l);
    StackDestroy(&l);
    return ret;
}

（2）用栈实现队列

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 StackInit(Stack* ps)
{
	assert(ps);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
// 入栈 
void StackPush(Stack* ps, STDataType data)
{
	//若ps为NULL，则不成立
	assert(ps);
	//如果top==capacity的话，则需要扩容
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;//如果capacity为0的话 则给它初始化成4，如果不为0的话，就扩成capacity的2倍
		STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
		if (tmp == NULL)//开辟空间失败
		{
			perror("realloc");
			return;
		}
		ps->a = tmp;
		ps->capacity = newcapacity;
	}
	ps->a[ps->top] = data;
	ps->top++;
}
// 出栈 
void StackPop(Stack* ps)
{
	assert(ps);//若栈为空，则出不了元素
	assert(ps->top != 0);
	ps->top--;
}
// 获取栈顶元素 
STDataType StackTop(Stack* ps)
{
	assert(ps);
	assert(ps->top > 0);
	return ps->a[ps->top-1];
}
// 获取栈中有效元素个数 
int StackSize(Stack* ps)
{
	assert(ps);
	return ps->top;
}
// 检测栈是否为空，如果为空返回非零结果，如果不为空返回0 
int StackEmpty(Stack* ps)
{
	assert(ps);
	return ps->top == 0;//如果等于0的话为空返回0 显示错误，返回其他>0的数则是为真
}
// 销毁栈 
void StackDestroy(Stack* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->capacity = 0;
	ps->top = 0;
}
//创建一个包含两个栈的结构体,一个用来进数据，一个用来出数据
typedef struct MyQueue
{
    Stack enstack;
    Stack popstack;
}MyQueue;
//创建一个包含两个栈的结构体
MyQueue* myQueueCreate() {
    MyQueue* q = (MyQueue*)malloc(sizeof(MyQueue));
    StackInit(&(q->enstack));
    StackInit(&(q->popstack));
    return q;
}
//进队列
//进数据，Push到enstack中
void myQueuePush(MyQueue* obj, int x) {
    StackPush(&(obj->enstack),x);
}
//出队列
//取队头元素，出队
int myQueuePop(MyQueue* obj) {
    int tmp = myQueuePeek(obj);
    StackPop(&(obj->popstack));
    return tmp;
}
//核心代码
int myQueuePeek(MyQueue* obj) {
    //如果出队列的栈为空，则从进队列的栈中获取数据，Push进出队列的栈中
    if(StackEmpty(&(obj->popstack)))
    {
        while(!StackEmpty(&(obj->enstack)))
        {
            StackPush(&(obj->popstack),StackTop(&(obj->enstack)));
            StackPop(&(obj->enstack));
        }
    }
    //返回队头元素，即是出队列的栈的栈顶数据
    return StackTop(&(obj->popstack));
}
//判断队是否为空，两个栈都为空
bool myQueueEmpty(MyQueue* obj) {
    return StackEmpty(&(obj->enstack))&&StackEmpty(&(obj->popstack));
}
//销毁
void myQueueFree(MyQueue* obj) {
   StackDestroy(&(obj->enstack));
   StackDestroy(&(obj->popstack));
    free(obj);
}

/**
 * Your MyQueue struct will be instantiated and called as such:
 * MyQueue* obj = myQueueCreate();
 * myQueuePush(obj, x);
 
 * int param_2 = myQueuePop(obj);
 
 * int param_3 = myQueuePeek(obj);
 
 * bool param_4 = myQueueEmpty(obj);
 
 * myQueueFree(obj);
*/

图例：

WG_17
关注
  • 5
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C例子：栈C语言实现
06-14
在C语言中，栈是一种非常基础且重要的数据结构，它遵循“后进先出”（LIFO，Last In First Out）的原则。栈常用于函数调用、表达式求值、内存管理等多种场景。本示例将详细介绍如何用C语言实现一个简单的栈。 首先...
完整开源ZigBee协议栈C语言代码
06-17
"完整开源ZigBee协议栈C语言代码"是一个重要的资源，因为它提供了一个详细的实现参考，可以帮助开发者理解和掌握ZigBee协议的工作原理。C语言是系统编程的常用语言，因此这个开源项目特别适合硬件开发者和嵌入式系统...
顺序栈 C语言 进栈 出栈 遍历
宗谷的博客
04-05 9195
本文摘自《大话数据结构》 帮助大家书写顺序栈代码
C语言中的栈
m0_63188530的博客
12-09 6898
1. 栈的定义： 限定仅在表尾进行插入或删除的线性表（后进先出LIFO：Last in , First out）。表头端称为栈底，表尾端称为栈顶。不含元素的空表称为空栈。 2. 栈的建立以及初始化 栈类似于线性表，有两种存储表示方法：顺序栈和链栈。 顺序栈 : 利用一组地址连续的存储单元依次存放字栈底到栈顶的元素，同时附设指针top指示栈顶元素在顺序栈中的位置，top=0为空栈。（栈所需大小难以估计，通常先分派一个基本容量，不够时再追加） 顺序栈的定义：建立一个结构体，包含栈...
C语言-栈
qinshaang的博客
10-08 2303
栈 一、栈的定义   栈作为一种限定性线性表，是将线性表的插入和删除操作限制在仅在表的一端进行，通常将表中允许进行插入、删除操作的一端称为栈顶(Top)，因此栈顶的当前位置是动态变化的，它由一个称为栈顶指针的位置指示器来指示。同时，表的另一端称为栈底(Bottom)。当栈中没有元素时称为空栈。栈的插入操作被形象的称为进栈或入栈，删除操作称为出栈或退栈。栈的修改是按先进后出的原则进行的。 二、栈的表...
顺序栈C语言实现
岳麓丹枫
05-11 1991
“`#include <stdio.h>#define MAXSIZE 10001 #define ELEMTYPE int #define STACK_EMPTY -9999 #define N 10typedef struct stack { ELEMTYPE data[MAXSIZE]; int top; } Seq_Stack; void initStack(Seq_Stac
C语言——栈
热门推荐
sqjddb的博客
08-10 1万+
栈的定义 栈（stack）又名堆栈，是一种限定仅在表尾进行插入和删除操作的线性表 这一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出的原则。 向一个栈插入新元素又称作进栈、入栈或压栈，使之成为新的栈顶元素 从一个栈删除元素又称作出栈或退栈。 C语言实现栈 分析： 可以使用数组或者链表实现，但数组在尾上插入数据的代价比较小。完整程序如下： 头文件 #include<stdio.h> #include<stdbool.h> #include<stdlib.h> #i
C语言数据结构——栈
wxk2227814847的博客
03-01 1584
在计算机科学中，数据结构是组织、管理和存储数据的有效方式，以便可以高效地访问和修改数据。栈是一种基本的数据结构，它遵循特定的操作顺序，即后进先出（LIFO）。由于其简单和高效的特性，在许多算法和系统功能中都有应用，如系统调用栈、表达式求值和回溯算法等。栈是一种简单而强大的数据结构，它在算法设计和系统实现中扮演着重要的角色。通过静态或动态的方式实现栈，可以在不同的应用场景中有效地利用其后进先出的特性。深入理解栈的工作原理和应用，对于学习更复杂的数据结构和算法是非常有帮助的。
数据结构：栈C语言实现
weixin_51885188的博客
11-08 1567
目录 栈的概念及结构 栈的实现 栈的初始化 栈的销毁 压栈 出栈 返回栈顶的元素 统计栈中的元素个数 判断栈是否为空 栈的概念及结构 栈：一种特殊的线性表，其只允许在固定的一段进行插入和删除元素操作。进行数据插入和删除操作的一段被称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO(Last In First Out)的原则。 压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。出数据也在栈顶。 它这个结构有点类似于子弹的弹夹，我们.
C语言之栈
hwx1546的博客
02-26 1587
栈是一种线性的数据结构，栈有以下的特点 栈是一种先进后出的数据结构，有点类似于堆盘子，先放到地上的盘子最后一个才取走 栈的数据口即能当入口也能当出口 下面通过示意图来描述栈的实现 下面是用程序来实现一个栈的功能。 stack.c #include "stack.h" #include <stdlib.h> #include <stdio.h> stack_t * stack_init(int num) { stack_t *temp; temp = (stack_t
数据结构-堆/栈 C语言实现
weixin_53284122的博客
03-08 612
【代码】数据结构-堆/栈 C语言实现。
C语言函数调用栈
weixin_55305220的博客
03-14 2392
在32位程序中，寄存器ebp指向栈帧的底部，用来存储当前栈帧的基址，在函数运行过程中不变，可以用来索引函数参数和局部变量的位置。当caller调用callee时，callee对应的栈帧就会被开辟，当调用结束返回caller时，callee对应的栈帧就会被销毁。将caller调用callee后的下一条指令的地址压入栈中，作为callee的返回地址，这样，当函数返回后可以正常执行接下来的指令。，从后面的代码来看，开辟的空间用于存放局部变量，那为什么不是在局部变量定义的时候将局部变量的值入栈，再移动esp呢？
Stack 栈 C语言实现
05-12
可运行C语言版本参考严蔚敏版本的数据结构与算法书，希望对正在学习的同学或者考研的同学有所帮助，我的代码都是在VC6.0上编写，编译。 #ifndef MAZE_H_ #define MAZE_H_ #include "stack.h" /** * position */ ...
基于栈的C语言迷宫问题与实现.docx
03-13
基于栈的C语言迷宫问题与实现 在计算机科学中，迷宫问题是一个经典的问题，旨在寻找从入口到出口的路径。该问题可以使用栈来解决，本文将对基于栈的C语言迷宫问题进行详细的分析和实现。 迷宫问题的描述： 迷宫...
C语言实现颠倒栈的方法
09-04
在C语言中，实现颠倒栈的操作涉及到对栈这一数据结构的基本操作，包括入栈、出栈以及递归等编程技巧。栈是一种后进先出（LIFO, Last In First Out）的数据结构，通常用于临时存储和处理数据。在本例中，我们将探讨...
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 352
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio
java版的上门家政系统和PHP版的上门家政有什么区别？
baina666的博客
07-12 384
综上所述，Java版和PHP版的上门家政系统各有优缺点，选择哪种语言主要取决于项目的具体需求、预算、开发团队的技术栈以及未来的扩展计划等因素。同时，由于Java生态系统的复杂性和多样性，也可能需要投入更多的时间和资源来学习和掌握相关的技术和工具。Java版：Java拥有庞大的生态系统和丰富的第三方库，这为家政系统的开发和扩展提供了强大的支持。Java版：由于Java的编译执行机制和高效的垃圾回收算法，Java版家政系统通常具有更高的运行效率和更好的性能表现，尤其是在处理高并发、大数据量等复杂场景时。
关于static定义初始化块和静态变量以及初始化块的执行顺序问题
你我约定有三的博客
07-08 448
第二步：在类加载的时候，按照从上到下执行static修饰的代码，此时执行static Test2 test1 = new Test2()，也就是创建出一个名为test1的对象。第六步：此时除了main方法，所有由static修饰的代码全部执行完毕(static修饰的代码只执行一次)，类初始化完成，开始执行main方法，main方法中只有一条语句(中的代码,此时输出aa以及a的值(由于第一步没赋初值，并且给了默认值为0 所以输出0)//首先输出a的值为10 然后输出bb，最后将a的值定义为11。
java Object 转 Integer
servepeople的博客
07-09 1450
在 Java 中，可以通过多种方法将一个Object转换为Integer。
数据结构顺序栈 c语言
10-13
在C语言中，可以通过定义一个数组和一个指向栈顶元素的指针来实现顺序栈。具体实现如下： ``` #define MAXSIZE 100 // 定义栈的最大容量 typedef struct { int data[MAXSIZE]; // 存放栈中元素的数组 int top; /...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值