数据结构 (六) 线性表_栈

已于 2022-04-24 13:51:55 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： 数据结构_C语言实现 文章标签： 数据结构 c语言 开发语言
于 2022-04-24 13:51:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fioman_GYM/article/details/124363265
版权

文章目录

一. 栈的基本概念

  1. 栈首先也是线性表,只是栈是一个受限的线性表.
  2. 栈具有前驱和后继的关系.
  3. 插入只能插入到栈顶,删除也是
  4. 栈的数据入口和出口相同,都是栈顶,所以栈后进先出

二. 栈的特性

  1. LIFO后进先出
  2. 出栈和入栈只有一个入口,就是栈顶

三. 基于顺序存储的栈结构

① 顺序存储的栈的概念

栈的顺序存储结构简称顺序栈,它是运算受限制的顺序表.顺序栈的存储结构是:利用一组地址连续的内存单元依次存放自栈底到栈顶的数据元素,同时设定top只是栈顶元素在顺序表中的位置

② 顺序存储栈的实现

因为栈是一种特殊的线性表,所以栈的顺序存储可以通过顺序线性表来实现

③ 使用数组模拟栈的顺序存储

栈顶放到数组的后面,这样数据插入的时候,不用频繁的移动

实现部分 SeqStack.h

#pragma once
#include <stdlib.h>
#include <stdio.h>
#define MAX_SIZE  1024
#define SEQ_STACK_TRUE 1
#define SEQ_STACK_FALSE 0

// 使用数组模拟栈操作,栈使用顺序存储来实现
typedef struct SeqStack
{
	void *data[MAX_SIZE];
	int size;
} SeqStack;

// 栈的操作
SeqStack *init_seq_stack();

// 入栈
void push_seq_stack(SeqStack *stack, void *data);

// 出栈
void pop_seq_stack(SeqStack *stack);

// 返回栈顶元素
void *top__seq_stack(SeqStack *stack);

// 判断是否为空
int is_empty(SeqStack *stack);

// 获取栈中元素个数
int get_size(SeqStack *stack);

// 清空栈
void clear_seq_stack(SeqStack *stack);

// 销毁栈
void destroy_seq_stack(SeqStack *stack);

SeqStack.c

#include "SeqStack.h"

// 栈的操作
SeqStack *init_seq_stack()
{
	SeqStack *stack =(SeqStack*) malloc(sizeof(SeqStack));
	// 这里分配内存的时候数组有没有分配内存呢,可以查看一下seqStack的大小
	//printf("sizeof(SeqStack) = %zu\n", sizeof(SeqStack));
	if (stack != NULL)
	{
		// 数组初始化
		for (int i = 0; i < MAX_SIZE; i++)
		{
			stack->data[i] = NULL;
		}
		stack->size = 0;
	}
	return stack;
}

// 入栈
void push_seq_stack(SeqStack *stack, void *data)
{
	if (stack->size == MAX_SIZE)
	{
		return;
	}
	if (stack != NULL && data != NULL)
	{
		stack->data[stack->size] = data;
		stack->size++;
	}
}

// 出栈
void pop_seq_stack(SeqStack *stack)
{
	if (stack != NULL && stack->size > 0)
	{
		stack->data[stack->size - 1] = NULL;
		stack->size--;
	}
}

// 返回栈顶元素
void *top__seq_stack(SeqStack *stack)
{
	if (stack != NULL && stack->size > 0)
	{
		return stack->data[stack->size - 1];
	}
	return NULL;
}

// 判断是否为空
int is_empty(SeqStack *stack)
{
	if (stack != NULL)
	{
		return stack->size == 0 ? SEQ_STACK_TRUE : SEQ_STACK_FALSE;
	}
	return SEQ_STACK_TRUE;
}

// 获取栈中元素个数
int get_size(SeqStack *stack)
{
	if (stack != NULL)
	{
		return stack->size;
	}
	return -1;
}

// 清空栈
void clear_seq_stack(SeqStack *stack)
{
	if (stack != NULL)
	{
		for (int i = 0; i < stack->size; i++)
		{
			stack->data[i] = NULL;
		}
		stack->size = 0;
	}
}

// 销毁栈
void destroy_seq_stack(SeqStack *stack)
{
	if (stack != NULL)
	{
		free(stack);
	}
}

测试代码:

#include "SeqStack.h"

typedef struct Person
{
	char name[64];
	int age;
} Person;


int main()
{
	SeqStack* stack =  init_seq_stack();
	// 创建数据
	Person p1 = { "P1",10 };
	Person p2 = { "P2",20 };
	Person p3 = { "P3",30 };
	Person p4 = { "P4",40 };
	Person p5 = { "P5",50 };

	// 入栈
	push_seq_stack(stack, (void *)&p1);
	push_seq_stack(stack, (void *)&p2);
	push_seq_stack(stack, (void *)&p3);
	push_seq_stack(stack, (void *)&p4);
	push_seq_stack(stack, (void *)&p5);

	// 获取栈顶元素,然后出栈,看看是不是后进先出
	Person *p;
	for (int i = 0; i < 5; i++)
	{
		// 获取栈顶元素,出栈
		p = (Person *)top__seq_stack(stack);
		pop_seq_stack(stack);

		printf("第 %d 个栈顶元素: 姓名: %s 年龄: %d \n", i + 1, p->name, p->age);
	}
	// 打印的顺序: P5,P$,P4,P2,P1

	// 获取栈的大小,因为都出栈了,所以这里的大小为0
	printf("栈的大小: %d\n", stack->size);
	push_seq_stack(stack, (void*)&p1);
	push_seq_stack(stack, (void *)&p2);

	printf("栈的大小: %d\n", stack->size); // 2

	// 清空栈
	clear_seq_stack(stack);
	printf("栈的大小: %d\n", get_size(stack));

	destroy_seq_stack(stack);


	system("pause");
	return 0;
}

结果:

四. 基于链式存储的栈结构

① 链式栈(链栈基本概念)

使用链表实现栈,主要是用单链表,并且插入和删除操作只有一个入口,就是链表的第一个元素.
栈顶top第一个节点,next指向下一个节点,栈底节点的next指向NULL

② 链式栈的实现

LinkStack.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#define LINK_SATCK_TRUE 1
#define LINK_STACK_FALSE 0

typedef struct LinkNode
{
	struct LinkNode *next;
} LinkNode;


// 链式栈
typedef struct LinkStack
{
	struct LinkNode head;
	int size;
} LinkStack;


// 初始化函数
LinkStack *init_link_stack();

// 入栈
void push_link_stack(LinkStack *stack, LinkNode *data);

// 出栈
void pop_link_stack(LinkStack *stack);

// 返回栈顶元素
LinkNode *top_link_stack(LinkStack *stack);

// 栈是否为空
int is_empty_link_stack(LinkStack *stack);

// 返回栈的大小
int get_size_link_stack(LinkStack *stack);

// 清空栈
void clear_link_stack(LinkStack *stack);

// 销毁栈
void destroy_link_stack(LinkStack *stack);

LinkStack.c

#include "LinkStack.h"
// 初始化函数
LinkStack *init_link_stack()
{
	// 为stack分配内存
	LinkStack *stack = (LinkStack* )malloc(sizeof(LinkStack));
	if (stack != NULL)
	{
		// 将头节点指向空,表示头尾重合没有其他的节点
		stack->head.next = NULL;
		stack->size = 0;
		return stack;
	}
	return NULL;
}

// 入栈
void push_link_stack(LinkStack *stack, LinkNode *data)
{
	// 插入到头部
	// 新节点指向头部的后继节点
	// 头部的后继节点指向新节点
	if (stack != NULL && data != NULL)
	{
		data->next = stack->head.next;
		stack->head.next = data;
		stack->size++;
	}


}

// 出栈
void pop_link_stack(LinkStack *stack)
{
	if (stack != NULL && stack->size > 0)
	{
		// 先找到栈顶元素
		LinkNode *nodeDel = stack->head.next;
		// 将头部指向栈顶元素的下一个节点
		stack->head.next = nodeDel->next;
		stack->size--;
	}
}

// 返回栈顶元素
LinkNode *top_link_stack(LinkStack *stack)
{
	if (stack != NULL && stack->size > 0)
	{
		return stack->head.next;
	}
	return NULL;
}

// 栈是否为空
int is_empty_link_stack(LinkStack *stack)
{
	if (stack != NULL)
	{
		return stack->size == 0 ? LINK_SATCK_TRUE : LINK_STACK_FALSE;
	}
	return LINK_STACK_FALSE;
}

// 返回栈的大小
int get_size_link_stack(LinkStack *stack)
{
	if (stack != NULL)
	{
		return stack->size;
	}
	return -1;
}

// 清空栈
void clear_link_stack(LinkStack *stack)
{
	if (stack != NULL)
	{
		stack->head.next = NULL;
		stack->size = 0;
	}
}

// 销毁栈
void destroy_link_stack(LinkStack *stack)
{
	if (stack != NULL)
	{
		free(stack);
	}
}

测试代码:

#include "LinkStack.h"

typedef struct Person
{
	LinkNode *node;
	char name[64];
	int age;
} Person;


int main()
{
	// 创建Person
	Person p1, p2, p3, p4, p5;
	int arrLen = sizeof(p1.name) / sizeof(p1.name[0]);
	strcpy_s(p1.name, arrLen, "P1");
	strcpy_s(p2.name, arrLen, "P2");
	strcpy_s(p3.name, arrLen, "P3");
	strcpy_s(p4.name, arrLen, "P4");
	strcpy_s(p5.name, arrLen, "P5");

	p1.age = 10;
	p2.age = 20;
	p3.age = 30;
	p4.age = 40;
	p5.age = 50;

	// 创建栈,然后入栈
	LinkStack *stack = init_link_stack();
	push_link_stack(stack, (LinkNode *)&p1);
	push_link_stack(stack, (LinkNode *)&p2);
	push_link_stack(stack, (LinkNode *)&p3);
	push_link_stack(stack, (LinkNode *)&p4);
	push_link_stack(stack, (LinkNode *)&p5);

	Person *p;
	// 出栈,并且打印
	for (int i = 0; i < 5; i++)
	{
		p = (Person *)top_link_stack(stack);
		pop_link_stack(stack);
		printf("第 %d 次,栈顶元素: 姓名: %s, 年龄: %d \n", i + 1, p->name, p->age);
	}

	// 出栈之后的大小为0
	printf("出栈完成之后,栈大小: %d\n", stack->size);

	// 再放入两个节点p1和p2
	push_link_stack(stack, (LinkNode *)&p1);
	push_link_stack(stack, (LinkNode *)&p2);

	// 栈大小为2
	printf("放入两个节点之后的栈大小: %d\n", stack->size);
	p = (Person *)top_link_stack(stack);// 栈顶
	printf("栈顶节点: 姓名: %s,年龄: %d\n", p->name, p->age);

	// 清空栈
	clear_link_stack(stack);
	printf("清空栈之后的栈的大小: %d\n", stack->size);

	destroy_link_stack(stack);
	system("pause");
	return 0;
}

结果:
在这里插入图片描述

Fioman_Hammer
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构与算法】线性表--栈和队列(Stack & Queue)【详解】
DreamSun的博客
03-25 1939
栈（Stack）是只允许在一端进行插入或删除的线性表。首先栈是一种线性表，但限定这种线性表只能在某一端进行插入和删除操作。栈顶（Top）：线性表允许进行插入删除的那一端。栈底（Bottom）：固定的，不允许进行插入和删除的另一端。空栈：不含任何元素的空表。栈又称为后进先出（Last In First Out）的线性表，简称LIFO结构递归是一种重要的程序设计方法。简单地说,若在一个函数、过程或数据结构的定义中又应用了它自身,则这个函数、过程或数据结构称为是递归定义的,简称递归。
数据结构与算法（java）：线性表-栈
lalala_dxf的博客
02-21 681
栈 栈的某些应用
线性结构 -- 栈
yunfan
09-15 4969
前言 栈和队列是两种重要的线性结构。从数据结构角度看，栈和队列也是线性表，其特殊性在于栈和队列的基本操作是线性表操作的子集，它们是操作受限的线性表，因此，可称为限定性的数据结构。但从数据类型角度看，它们是和线性表不相同的两类重要的抽象数据类型。 一 栈的定义和特点 1.1 栈的定义 栈(Stack) 是限定仅在表尾进行插入或删除操作的线性表。因此，对栈来说，表尾端有其特殊含义，称为栈顶(top)，相应地，表头端称为栈底(bottom)。不含元素的空表称为空栈。 1....
第11节 栈的定义及实现
一名从事物联网开发者的博客
02-13 182
-------------------------------------资源来源于网络,仅供自学使用,如有侵权,联系我必删. 第一: 栈的定义 ? 栈是一种特殊的线性表 ? 栈仅能在线性表的一端进行操作 ?  栈顶(Top) ： 允许操作的一端 ?  栈底(Bottom) ： ：不允许操作的一端 ? 性质 ： 后进先出(  LIFO ) 第二: ? 栈的一些常用操作 ?  创建栈 ?...
【线性表】栈
小景的博客
12-10 1267
目录 一、栈的定义 二、如何实现一个栈 1、数组实现 2、链表实现 三、栈的应用场景 1、使用栈来反转表或集合 2、括号匹配   一、栈的定义 栈：栈是一种“操作受限”的线性表。栈的主要操作有2个：入栈（在栈顶插入一个数据）、出栈（在栈顶删除一个数据）。 受限一定不好吗？ 非也。从功能上来说，数组/链表可以替代栈，但它们暴露了太多的操作接口，使用时不可控；此外，特定的结构是...
数据结构之线性表（一）
以前冷现在热
10-30 383
本文主要是线性表的顺序存储结构和链式存储结构的实现和代码。 线性表的定义 线性表:零个或多个数据元素的有限序列 序列说明元素之间是有顺序的,若元素存在多个,则第一元素无前驱,最后一个元素无后继,其他元素都有且只有一个前驱和后继。有限说明元素的个数是有限的,所有在计算机中处理的数据对象都是有限的。另外在线性表的定义中，只有相同的数据类型。比如大学占位置，有一个同学拿着水杯占了三个位置，这其实并...
数据结构线性表(一)
OnlyFeiger的博客
01-05 310
数据结构之线性表(一) 线性表 是数据结构中最简单且常用的一种结构 它由相同的数据类型的n个元素组成的有限序列 按照存储结构,可以分为 顺序表和链表两种 顺序表 主要特点是可以进行随机访问,可以通过表头元素的地址和元素的下标在O(1)的时间复杂度找到指定元素,主要介绍***构造,插入,扩容,查找,删除,遍历***这些操作 特点 顺序表是用一组地址连续的储存单元依次存储数据元素,元素在逻辑和物理位置上是相邻的 缺点: 插入和删除要移动大量的元素从而保持逻辑和物理上的连续性. 构造顺
《数据结构与算法》课程上机实验一（线性表）_C++_数据结构与算法_线性表_
10-03
同时，对C++的数据结构和算法有更深入的了解，为后续的高级数据结构如链表、栈、队列以及树等奠定坚实的基础。此外，理解这些基本概念对于提升问题解决能力和算法设计能力至关重要，对于未来在IT行业的职业发展有着...
线性表_线性表_
10-03
线性表是一种基础的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在计算机科学中，理解和掌握线性表对于学习其他更复杂的数据结构至关重要。线性表具有顺序特性，即每个元素都有一个前驱元素和一个后继...
数据结构：线性表、链表、队列、栈、串
11-24
本主题将深入探讨线性表、链表、队列、栈这四种基本的数据结构，并以C++语言为例，通过相关源代码（stringData.cpp、seqList.cpp、node.cpp、seqQueue.cpp、linkQueue.cpp、linkStack.cpp、seqStack.cpp）来解析其...
DataAndAlgorithm_C#数据结构与算法_栈和队列_
09-29
本资源"DataAndAlgorithm_C#数据结构与算法_栈和队列_"专注于这两种基础但关键的数据组织方式：栈和队列，以及它们在C#语言中的实现。 栈是一种后进先出（LIFO，Last In First Out）的数据结构，常被比喻为“堆叠的...
数据结构中线性表，队列和栈
01-07
线性表、栈和队列是数据结构中的基本概念，它们在编程中有着广泛的应用。 1. 线性表： 线性表是一种最简单、最基本的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。这些元素可以按顺序存储，如数组，也...
线性表之栈（数据结构day05)
he_zhen_的博客
01-26 141
栈 什么是栈 &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;栈，stack,是限定在表的一端进行插入和删除预算的线性表 　　通常，将删除与插入的一端称为栈顶，每次退栈（即删除一个元素）的必是最后一个进栈的元素，而第一个进栈的元素必然是最后一个退栈的。即在栈中，元素具有先进后出，后进先出的特点，故把栈也称为先进后出的线性表，LIFO表（Last in first out). 栈的顺序存...
数据结构——线性表——栈
m0_50708613的博客
01-28 2648
一、栈 1.栈的定义 栈是只能从一端存取数据和读取数据且遵循 "先进后出" 或“后进后出”原则的线性存储结构。 2.栈的分类 与线性表存储结构类似，栈也有两种存储结构：顺序存储结构和链式存储结构。 二、栈的顺序存储结构 1.顺序栈的定义 顺序栈：即用顺序存储结构方式设计栈的存储数据，从而实现栈存储结构。 顺序栈通常有一个一维数组data和一个记录栈顶元素位置的变量top组成，底部称为栈底，头部称为栈顶。如图所示： 3.顺序栈是四要素 设顺序栈为st. (1)栈空：st.to...
线性表——栈
qq_45775250的博客
10-24 1676
栈 概念 栈是一种特殊的线性表，栈只允许在尾端进行插入和删除，就如同弹夹上子弹一样，后入先出（LIFO(last in first out)），允许进行插入和删除的一端称之为栈顶(top)，另一端为栈底(bottom)。通常我们将栈的插入操作称之为入栈(push)，删除操作称为出栈(pop)。 ...
数据结构 - 线性表、栈、队列、串
持续学习中
09-24 5761
作者：谭东 最近把之前学过的数据结构和算法部分都重新研究看完了，整理分享一下。 前言感想：之前遇到有人说不要说重复的东西，网上都有了，书里都有这些概念了。我听到之后很诧异，很感叹这个人或者这些人可能没有真正的去学习或者学懂数据结构吧？数据结构是什么？用来干嘛的？逻辑原理意图是什么？其实很多东西不是一进来就要直接学习多么高难度高深的算法什么的，没有基础知识的支撑、没有真正的学懂其思维逻辑，你......
线性表与栈
远方的博客
08-28 1014
线性表是n个数据特性相同的元素的组成有限序列，是最基本且常用的一种线性结构(线性表，栈，队列，串和数组都是线性结构），同时也是其他数据结构的基础。 线性表最核心的是这几种基本方法，即： 一、判断线性表是否为空 二、得到线性表的大小 三、得到线性表中的某个元素或某个元素的索引 四、插入或删除元素 五、输出线性表中的元素 这几种方法都可...
数据结构—链式二叉树-C语言
最新发布
h_number_1的博客
07-11 1018
上述内容，即是我个人对数据结构-链式二叉树-搜索二叉树-C语言的个人见解以及自我实现。若有大佬发现哪里有问题可以私信或评论指教一下我这个小萌新。
DataStructure.pdf
05-01
本文档详细介绍了数据结构中的基本概念和常见操作，涵盖了线性表、栈和队列、字符串、数组、广义表以及树和二叉树等重要主题。 1. 线性表 - 顺序表：通过数组实现，提供了初始化、获取元素、查找元素、插入、删除...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值