【C语言数据结构】栈(顺序栈+链栈)

已于 2022-03-27 20:12:15 修改
阅读量2.5k 收藏 22
点赞数 3
分类专栏： C语言 数据结构 文章标签： c语言
于 2022-03-25 16:14:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/W1024201/article/details/123735161
版权

目录

文章目录

前言

一、顺序栈

1.顺序栈头文件及函数声明

2.初始化

3.扩容

4.入栈

5.获取栈顶元素 

 6.出栈

 7.清空与销毁

1.清空

2.销毁

8.顺序栈源文件及整体函数实现 

二、链栈 

1.链栈头文件及函数声明

2.初始化

3.结点申请

4.入栈

5.获取栈顶元素 

 6.出栈

 7.清空与销毁

1.清空

2.销毁

8.顺序栈源文件及整体函数实现 

总结
 

前言

栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈类似于子弹弹夹，入栈就像是装弹，出栈就像是退弹。

因为其是受到限制的线性表，则可以有两种实现方式，顺序表实现和链表实现，以下为实现方式：

一、顺序栈

1.顺序栈头文件及函数声明

我们可以新建头文件"stack.h"对顺序表函数声明进行保存，方便我们后期查看及使用

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>

#define INIT_SIZE 10

typedef int Element;

typedef struct Stack
{
	Element* base;
	int top; //存在 Element *top 类型通过指针指向栈顶元素 ，此处int类型是通过数组访问
	int stackSize;
}Stack,*PStack;

//初始化栈
void Init_Stack(PStack ps);

//入栈
bool Push(PStack ps, Element val);

//出栈(如果出栈成功，需要告诉我出栈的值是多少，如果出栈失败，则无所谓)
bool Pop(PStack ps, Element* rtval);//rtval 是输出参数 帮助函数返回其他信息

//获取栈顶元素
bool Top(PStack ps, Element* rtval);

//获取有效元素个数
int GetSize(PStack ps);

//判空
bool IsEmpty(PStack ps);

//判满
bool IsFull(PStack ps);

//扩容函数
void Inc(PStack ps);

//清空
void Clear(PStack ps);

//销毁
void Destroy(PStack ps);

//打印
void Show(PStack ps);

2.初始化

我们需要一个栈的表头来帮助我们储存相关信息：

1.一个指向顺序栈的指针；

2.栈顶指针（实际为顺序表中下一个元素的插入位置，也是栈中有效值个数）

3.栈空间的总大小（可帮助我们扩容）

那么我们可以定义如下的一个结构体：

#define INIT_SIZE 10

typedef int Element;

typedef struct Stack
{
	Element* base;
	int top; //存在 Element *top 类型通过指针指向栈顶元素 ，此处int类型是通过数组访问
	int stackSize;
}Stack,*PStack;

接着我们实现一个初始化函数来对以上内容进行初始化：

//初始化栈
void Init_Stack(PStack ps)
{
	assert(ps != NULL);
    //为栈空间申请内存
	ps->base = (Element*)malloc(INIT_SIZE * sizeof(Element));
	if (ps->base == NULL)
	{
		exit(1);
	}
	ps->top = 0;
	ps->stackSize = INIT_SIZE;
}

 完成以上操作，我们就得到一个简单的空的顺序栈，接下来可以对其进行相关操作。

3.扩容

当我们对更多数据进行存储时，我们就需要扩充栈的大小，来进一步保存数据。

在这里以3/2倍扩容。

//扩容函数
void Inc(PStack ps)
{
	assert(ps != NULL && ps->base != NULL);
	ps->base = (Element*)realloc(ps->base, sizeof(Element)  * ps->stackSize * 2);
	if (ps->base == NULL)
	{
		exit(1);
	}
	ps->stackSize = ps->stackSize * 3 / 2;
}

封装扩容函数，可方便对数据的保存，减少为了扩容产生代码冗余。

4.入栈

对数据进行入栈，即是直接对栈中顺序表下一个空位置进行赋值操作。

//入栈
bool Push(PStack ps, Element val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (IsFull(ps))//栈满需扩容
	{
		Inc(ps);
	}
	//入栈
	ps->base[ps->top] = val;
	ps->top++;//或者添加至上一步，这里因为后期理解方便

	return true;
}

5.获取栈顶元素 

这里与出栈基本相同，但是无需删除数据。

rtval是输出参数，帮助获取栈顶元素。

//获取栈顶元素   与出栈不同的是 不用减top
bool Top(PStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->base[ps->top - 1];
	return true;
}

 6.出栈

rtval是输出参数，帮助获取出栈元素。

//出栈(如果出栈成功，需要告诉我出栈的值是多少，如果出栈失败，则无所谓)
bool Pop(PStack ps, Element* rtval)//rtval 是输出参数 帮助函数返回其他信息
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	ps->top--;
	*rtval = ps->base[ps->top];
	return true;
}

 7.清空与销毁

1.清空

当栈中数据无需使用，我们可以对栈进行清空操作，实际即是将栈顶指针置为0；

//清空
void Clear(PStack ps)
{
	assert(ps != NULL);
	ps->top = 0;
}

2.销毁

销毁相当于进行初始化相反的操作，将向计算机申请的内存释放，将容量置为0。

//销毁
void Destroy(PStack ps)
{
	free(ps->base);
	ps->base = NULL;
	ps->stackSize = ps->top = 0;
}

8.顺序栈源文件及整体函数实现 

源文件："stack.c"

#include "stack.h"

//初始化栈
void Init_Stack(PStack ps)
{
	assert(ps != NULL);
	ps->base = (Element*)malloc(INIT_SIZE * sizeof(Element));
	if (ps->base == NULL)
	{
		exit(1);
	}
	ps->top = 0;
	ps->stackSize = INIT_SIZE;
}

//入栈
bool Push(PStack ps, Element val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	if (IsFull(ps))//栈满需扩容
	{
		Inc(ps);
	}
	//入栈
	ps->base[ps->top] = val;
	ps->top++;//或者添加至上一步，这里因为后期理解方便

	return true;
}

//出栈(如果出栈成功，需要告诉我出栈的值是多少，如果出栈失败，则无所谓)
bool Pop(PStack ps, Element* rtval)//rtval 是输出参数 帮助函数返回其他信息
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	ps->top--;
	*rtval = ps->base[ps->top];
	return true;
}

//获取栈顶元素   与出栈不同的是 不用减top
bool Top(PStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->base[ps->top - 1];
	return true;
}

//获取有效元素个数
int GetSize(PStack ps)
{
	return ps->top;
}

//判空
bool IsEmpty(PStack ps)
{
	return ps->top == 0;
}

//判满
bool IsFull(PStack ps)
{
	assert(ps != NULL);
	return ps->stackSize == ps->top;
}

//扩容函数
void Inc(PStack ps)
{
	assert(ps != NULL && ps->base != NULL);
	ps->base = (Element*)realloc(ps->base, sizeof(Element)  * ps->stackSize * 2);
	if (ps->base == NULL)
	{
		exit(1);
	}
	ps->stackSize = ps->stackSize * 3 / 2;
}

//清空
void Clear(PStack ps)
{
	assert(ps != NULL);
	ps->top = 0;
}

//销毁
void Destroy(PStack ps)
{
	free(ps->base);
	ps->base = NULL;
	ps->stackSize = ps->top = 0;
}

void Show(PStack ps)
{
	assert(ps != NULL);
	for (int i = 0; i < ps->top; i++)
	{
		printf("%d ", ps->base[i]);
	}
	printf("\n");
}

二、链栈 

1.链栈头文件及函数声明

我们可以新建头文件"lstack.h"对顺序表函数声明进行保存，方便我们后期查看及使用

#pragma once

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdlib.h>

typedef int Element;

typedef struct LStack
{
	Element data;//数据域
	struct LStack* next;// 指针域
}LStack,*PLStack;

//初始化链栈
void Init_LStack(PLStack ps);

//购买新结点
PLStack BuyNode();

//释放结点
void FreeNode(PLStack p);

//入栈
bool Push(PLStack ps, Element val);

//出栈
bool Pop(PLStack ps, Element* rtval);

//获取栈顶元素
bool Top(PLStack ps, Element* rtval);

//获取有效数据个数
int GetSize(PLStack ps);

//判空
bool IsEmpty(PLStack ps);

//清空
void Clear(PLStack ps);

//销毁
void Destroy(PLStack ps);

//打印
void Show(PLStack ps);

2.初始化

此处链栈的基础结点与单链表基本相同，但只是相较单链表来说，其权限被限制了一部分。

typedef int Element;

typedef struct LStack
{
	Element data;//数据域
	struct LStack* next;// 指针域
}LStack,*PLStack;

接着我们实现一个初始化函数来对以上内容进行初始化：

//初始化链栈
void Init_LStack(PLStack ps)
{
	assert(ps != NULL);
	ps->next = NULL;
}

 完成以上操作，我们就得到一个简单的空的链栈，接下来可以对其进行相关操作。

3.结点申请

因为链表的结构特性，我们需要对结点进行多次申请，为了方便进行其他函数操作，并且为了优化代码，我们将结点的申请封装于一个函数

//购买新结点
PLStack BuyNode()
{
	PLStack node = (PLStack)calloc(1, sizeof(LStack));
	if (node == NULL)
	{
		exit(1);
	}
	return node;
}

4.入栈

因为单链表的特性，要实现对栈顶的操作，即是直接对链表进行头部操作即可

对数据进行入栈，即是直接对栈链表进行头插操作。

//入栈
bool Push(PLStack ps, Element val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	PLStack newnode = BuyNode();
	newnode->data = val;
	newnode->next = ps->next;
	ps->next = newnode;
	return true;
}

5.获取栈顶元素 

这里与出栈基本相同，但是无需删除数据。

rtval是输出参数，帮助获取栈顶元素。

//获取栈顶元素
bool Top(PLStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->next->data;
	return true;
}

 6.出栈

rtval是输出参数，帮助获取出栈元素。

//出栈
bool Pop(PLStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->next->data;
	PLStack delnode = ps->next;
	ps->next = delnode->next;
	FreeNode(delnode);
	return true;
}

 7.清空与销毁

1.清空

当栈中数据无需使用，我们可以对栈进行清空操作，此处使用不断出栈的操作；

//清空
void Clear(PLStack ps)
{
	assert(ps != NULL);
	int rtval;
	while (!IsEmpty(ps))
	{
		Pop(ps, &rtval);
	}
}

2.销毁

销毁相当于进行初始化相反的操作，将向计算机申请的内存释放清空，并将链表头置为NULL。

//销毁
void Destroy(PLStack* ps)
{
	Clear(*ps);
	*ps = NULL;
}

8.顺序栈源文件及整体函数实现 

#include "lstack.h"

//初始化链栈
void Init_LStack(PLStack ps)
{
	assert(ps != NULL);
	ps->next = NULL;
}

//购买新结点
PLStack BuyNode()
{
	PLStack node = (PLStack)calloc(1, sizeof(LStack));
	if (node == NULL)
	{
		exit(1);
	}
	return node;
}

//释放结点
void FreeNode(PLStack p)
{
	free(p);
	p = NULL;
}

//入栈
bool Push(PLStack ps, Element val)
{
	assert(ps != NULL);
	if (ps == NULL)
	{
		return false;
	}
	PLStack newnode = BuyNode();
	newnode->data = val;
	newnode->next = ps->next;
	ps->next = newnode;
	return true;
}

//出栈
bool Pop(PLStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->next->data;
	PLStack delnode = ps->next;
	ps->next = delnode->next;
	FreeNode(delnode);
	return true;
}

//获取栈顶元素
bool Top(PLStack ps, Element* rtval)
{
	assert(ps != NULL);
	if (IsEmpty(ps))
	{
		return false;
	}
	*rtval = ps->next->data;
	return true;
}

//获取有效数据个数
int GetSize(PLStack ps)
{
	assert(ps != NULL);
	int num = 0;
	PLStack node = ps->next;
	while (node != NULL)
	{
		num++;
		node = node->next;
	}
	return num;
}

//判空
bool IsEmpty(PLStack ps)
{
	assert(ps != NULL);
	return ps->next == NULL;
}

//清空
void Clear(PLStack ps)
{
	assert(ps != NULL);
	int rtval;
	while (!IsEmpty(ps))
	{
		Pop(ps, &rtval);
	}
}

//销毁
void Destroy(PLStack ps)
{
	Clear(ps);
	ps = NULL;
}

//打印
void Show(PLStack ps)
{
	assert(ps != NULL);
	PLStack node = ps->next;
	for (int i = 0; i < GetSize(ps); i++)
	{
		printf("%d ", node->data);
		node = node->next;
	}
	printf("\n");
}

总结

以上就是今天要讲解的内容，本文简单介绍了栈的代码实现（包括链栈与顺序栈），栈为我们提供了数据结构的基础思想，能使我们快速便捷地处理数据的函数和方法。

W1024201
关注
专栏目录
栈和队列-数据结构与算法(C语言版)
monkeylvjava
05-17 1099
栈和队列 一、栈 1. 概述 栈是限定仅在表尾进行插入和删除操作的线性表。进行插入或删除操作的一端叫做栈顶，另一端称为栈底，没有数据元素的栈称为空栈，插入数据元素的操作称为入栈，删除数据元素的操作称为出栈。 栈的特性：**先进后出（FILO）**或者 后进先出（LIFO）。 栈的存储结构 顺序栈（顺序存储） 采用顺序存储结构模拟栈存储数据，因为每次分配固定大小的存储空间，操作不当可能产生上溢或者下溢。 链栈（链式存储） 采用链式存储结构实现 两种实现方式的区别，仅限于数据元素在实际物
数据结构C语言-顺序栈、共享栈、链栈的定义、销毁及出入栈操作
T1cH9的博客
06-12 1379
学习自用
【数据结构】栈【详解】૮₍ ˃ ⤙ ˂ ₎ა
2302_79862386的博客
01-01 945
int top;}ST;其中a是用来开辟空间的，top,capacity则分别是存储栈顶信息与栈的最大容量头文件的包含：int top;}ST;//栈的初始化assert(ps);//判空操作//为栈开创大小为四个STDataType的空间//如果开创失败就非正常退出程序exit(-1);//否则栈的最大容量为当前开创的空间大小//栈顶从头开始//摧毁栈assert(ps);//判空操作//释放ps->a中的内存并使其指向空，防止内存泄漏//同时容量置空，栈置零。
栈实现详解
2301_80464369的博客
04-03 455
栈也是一种数据结构，符合后进先出、在同一端进出的原则，像羊肉串一样，今天我们就来实现栈和其相关功能。要实现后进先出，我们可以使用链表也可以使用数组，哪种更好呢如果要用链表实现，则需要进行尾部删除与尾部插入，不难，8分如果用数组实现，则只需要充足的空间即可，代价更小，9分接下来我将用数组实现栈的初始化、销毁、入栈、出栈、找出栈顶元素、获取战中有效数据个数、检查栈是否为空功能。
数据结构——顺序栈和链式栈
最新发布
2301_80401288的博客
08-21 898
数据结构——栈 求点赞收藏关注！！！
数据结构-栈(C语言代码)
weixin_50246370的博客
08-12 5639
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 #include <stdio.h> #include <stdlib.h> typedef struct Node { int data; struct.
数据结构与算法C语言版本---栈
Yang_Jiang_Blog's
10-11 242
由于编者水平有限,如有错误,请多多包涵。 /* File name: Stack.cpp Description: 栈的初始化，压栈，出栈，判断栈是否为空，清空栈。 Author: Yang_Jiang Date: 2018年10月11日 Compiler：Visual Studio 2008 */ # include &lt;stdio.h&gt; # include &lt;s...
数据结构 -------- 栈
m0_64259792的博客
06-28 381
数据结构 ------ 栈的基础知识
创建栈
波风水门的博客
01-02 497
第一次尝试 //这是 .h 部分的代码 #pragma once //使用这种方式来重命名数据类型，这样可以很方便的修改后续数据的数据类型，相当于#define的作用 typedef int StackType; //创建栈 typedef struct Stack { //使用指针指向一块动态开辟的内存 StackType* _date; //表示栈中的有效数据，也代表了栈顶 size_t _size; //表示栈的最大容量 size_t _capacit
停车场管理系统(C语言顺序栈+链栈+链队列)
04-20
本项目以C语言为基础，运用了顺序栈、临时栈链栈和排队车道链队列的数据结构，为实现停车场管理提供了高效而灵活的解决方案。 首先，让我们深入了解这些数据结构： 1. **顺序栈**：顺序栈是一种线性数据结构，它...
c语言数据结构-栈队列数组完美版资料.ppt
11-14
本资源摘要信息主要关于C语言数据结构中的栈、队列和数组三个基本概念。栈是一种特殊的线性表，栈的定义是只能在一端插入和删除元素的线性表，特点是后进先出（LIFO）。栈的基本运算包括初始化、判栈空、判栈满、读...
C语言 栈的实现，包含顺序栈和链栈，亲测可用
04-25
本文将详细讨论在C语言中如何实现栈，包括顺序栈和链栈，并基于提供的文件名来解析它们的实现。 1. **顺序栈**：顺序栈是通过数组来实现的，其优点在于存储空间连续，访问速度快。`stack_array.c`和`stack_array.h`...
数据结构课程：顺序栈和链栈的实现
10-16
### 数据结构课程：顺序栈和链栈的实现 #### 栈的基本概念 栈是一种特殊的线性表，其特殊之处在于所有元素的插入和删除都只能在一端进行，这一端被称为栈顶(top)，与之相对的一端称为栈底(bottom)。栈通常支持以下...
[递归]使用栈解决n辆列车调度问题（列车编号1-n）
Linxi的专栏
11-05 3597
void Permutation(int n); void Recursion(int *a,int n,int k); void Print(int *a,int n); void PrintError(int *a,int n); void GetStackList(int *a,int n,int k); static int flag = 0; static int errorNum =
栈的创建（基础）
qq_52988578的博客
04-04 3727
栈：是限定仅在表尾进行插入和删除操作的线性表！ 栈的结构定义如下： typedef struct Stack { SLDataType *base;//栈底元素的地址 int top;//栈顶元素的位置 } Stack; 栈的初始化如下： SLDataType initStack(Stack &S) { S.base=(SLDataType*)malloc(N*sizeof(SLDataType));//申请栈元素的存储空间 if(S.base==NULL)
构建一个 “栈“
weixin_52533616的博客
01-20 601
栈是一种特殊的线性表，仅能在线性表的一端操作，栈顶允许操作，栈底不允许操作
数据结构与算法之栈
pizicai007的博客
04-16 205
1. 基本知识 1.1 概念 栈是一种操作受限的数据结构，只能在一端插入和删除数据，因此只支持入栈和出栈操作，后进先出是它的最大特点。栈可以通过数组实现，也可以通过链表来实现，其出栈和入栈的时间复杂度都是O(1)。 1.2 分类 顺序栈 链式栈 1.3 基本操作 入栈 push(T data) 出栈 pop() 获取栈顶数据 peek() 1.3 实现 只需要维护一个栈顶指针，通过数组实...
数据结构与算法——栈
Wu996的博客
03-05 544
什么是栈？ 栈就是先入后出，后入先出。那怎么理解栈呢，栈就像是一个羽毛球筒，数据就是一个一个的羽毛球，在工厂中，先把羽毛球放进去，我们在打羽毛球的时候，再依次从球筒中拿出来，但是我们最先拿出来的是最后放进去的；最先放进去的却是最后拿出来的。 数据结构 typedef struct Stack { /* data */ int top ;//栈顶 int base;//栈底 char data[100];//放数据,只有一百条数据 }stack,Stack; 入栈函数Pus
C语言实现：顺序栈与链栈操作详解
"数据结构课程涵盖了顺序栈和链栈的实现，主要使用C语言进行编程。顺序栈是基于一组连续存储单元实现的栈，而链栈则是通过链式存储结构来实现。这两种栈都支持常见栈操作，如初始化、入栈、出栈、取顶、查询栈长和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值