栈的链式存储和顺序存储的基本操作

已于 2022-05-04 22:40:39 修改
阅读量820 收藏 5
点赞数 2
分类专栏： 栈 文章标签： 数据结构 c++
于 2022-05-04 22:32:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63010894/article/details/124571561
版权

目录

一、闵版（顺序存储单指针）

1.完整代码

#include <stdio.h>
#include <iostream>

using namespace std;

#define MaxSize	10

typedef struct _Stack
{
	int top;
	int data[MaxSize];
}*CharStackPtr;


void outputStack(CharStackPtr paraStack)
{
	for(int i = 0;i<=paraStack->top;i++)
	{
		cout<<paraStack->data[i]<<" ";
	}

	cout<<endl;
}

CharStackPtr charStackInit()
{
	CharStackPtr resultPtr = new struct _Stack;

	resultPtr->top = -1;
	
	return resultPtr;
}

void push(CharStackPtr paraStackPtr, int paraValue)
{
	// Step 1. Space check.
	if(paraStackPtr->top >= MaxSize-1)
	{
		cout<<"Cannot push element: stack full.";
		return;
	}

	// Step 2. Update the top.
	paraStackPtr->top++;

	// Step 3. Push element.
	paraStackPtr->data[paraStackPtr->top] = paraValue;
}

int pop(CharStackPtr paraStackPtr)
{
	// Step 1. Space check.
	if(paraStackPtr->top < 0)
	{
		cout<<"Cannot pop element: stack empty."<<endl;
		return '\0';
	}

	// Step 2. Update the top.
	paraStackPtr->top--;

	// Step 3. Pop element.

	return paraStackPtr->data[paraStackPtr->top + 1];
}

void pushPopTest() {
    printf("---- pushPopTest begins. ----\r\n");

	// Initialize.
    CharStackPtr tempStack = charStackInit();
    printf("After initialization, the stack is: ");
	outputStack(tempStack);

	// Poush.
	for (int i = 0; i < 5; i++) {
		printf("Pushing %d.\r\n", i);
		push(tempStack, i);
		outputStack(tempStack);
	}

	// Pop.
	for (int i = 0; i < 3; i ++) {
		int ch = pop(tempStack);
		printf("Pop %d.\r\n", ch);
		outputStack(tempStack);
	}

    printf("---- pushPopTest ends. ----\r\n");
}

int main() {
	pushPopTest();

	system("pause");
}

2.运行结果

在这里插入图片描述

二、钦版（顺序存储双指针）

1.栈的示意图

在这里插入图片描述
单向进出，先进后厨，后进先出，就像一个死胡同一样。

2.结构体的创建

typedef struct _SqStack
{
	ElemType *base;//栈底指针
	ElemType *top;//栈顶指针
}SqStack;

3.栈的初始化

bool InitStack(SqStack &S)//构造一个空栈
{
	S.base = new  ElemType[MaxSize];//为栈分配一个MaxSize容量的空间
	
	if(!S.base)//内存分配失败
		return false;
	
	S.top = S.base;//空栈
	
	return true; 
}

在这里插入图片描述

4.压栈——元素入栈

//插入元素e为新的栈顶元素
bool PushStack(SqStack &S,ElemType e)
{
	if( (S.top - S.base) == MaxSize)//栈满
		return false;
	
	*(S.top++) = e;//元素e 入栈，栈顶指针向上引动 等价于 S.top = e; S.top++;
	
	return true;
}

在这里插入图片描述

5.出栈（只能从后面依次出栈）

//删除S的栈顶元素，暂存在变量e中，方便后续查看删除的是谁
bool PopStack(SqStack &S,ElemType &e)
{
	if(S.base == S.top)//栈空城 
		return false;
		
	e = *(--S.top);//由于S.top比较勤奋 ，指向的是栈顶的上一位，所以要先 -- 指向栈顶数据，再赋值
	
	return true; 
}

在这里插入图片描述
先进后出，后进先出是栈的特性。

6.获取栈顶元素

/*获取栈顶元素*/
ElemType GetTop(SqStack &S)
{
	if(S.top!=S.base)//栈非空 
		return *(S.top-1);
	else
		return 0; 
}

7.栈中元素的个数

//返回栈中元素个数
int GetSize(SqStack &S)
{
	return(S.top-S.base);
}

8.判断是否为空

//判断栈是否为空
bool IsEmpty(SqStack &S)
{
	if(S.top == S.base)//空 
		return true;
	else
		return false;
}

9.判断是否为满

bool IsFull(SqStack &S)
{
	if((S.top -S.base) == MaxSize)//空 
		return true;
	else
		return false;
}

10.摧毁栈

void DestoryStack(SqStack &S)
{
	if(S.base)
	{
		delete(S.base);
		S.base = NULL;
		S.top = NULL;
		cout<<endl<<"销毁成功!";
	}else
		cout<<"\n销毁失败!"<<endl;
}

11.完整代码

#include <Windows.h>
#include <iostream>
#include <stdlib.h>
#include <stdio.h>

using namespace std;

#define MaxSize 128//预先分配空间，这个数值根据实际需要预估确定

typedef int ElemType;


/*作业 :采用如下方法 
typedef struct _SqStack
{
	int top;//栈顶指针
	ElemType *top;//栈底指针
}SqStack; 
*/
typedef struct _SqStack
{
	ElemType *base;//栈底指针
	ElemType *top;//栈顶指针
}SqStack;

bool InitStack(SqStack &S)//构造一个空栈
{
	S.base = new  ElemType[MaxSize];//为栈分配一个MaxSize容量的空间
	
	if(!S.base)//内存分配失败
		return false;
	
	S.top = S.base;//空栈
	
	return true; 
} 

//插入元素e为新的栈顶元素
bool PushStack(SqStack &S,ElemType e)
{
	if( (S.top - S.base) == MaxSize)//栈满
		return false;
	
	*(S.top++) = e;//元素e 入栈，栈顶指针向上引动 等价于 S.top = e; S.top++;
	
	return true;
}

//删除S的栈顶元素，暂存在变量e中
bool PopStack(SqStack &S,ElemType &e)
{
	if(S.base == S.top)//栈空城 
		return false;
		
	e = *(--S.top);//由于S.top比较勤奋 ，指向的是栈顶的上一位，所以要先 -- 指向栈顶数据，再赋值
	
	return true; 
}

//法一：返回S的栈顶元素，栈顶指针不变
ElemType GetTop(SqStack &S)
{
	if(S.top!=S.base)//栈非空 
		return *(S.top-1);
	else
		return 0; 
}

//法二：
bool  GetTop2(SqStack &S,ElemType &e)
{
	if(S.top!=S.base)//栈非空 
	{
		e = *(S.top-1);	
		return true;
	}else
		return false;
}
//返回栈中元素个数
int GetSize(SqStack &S)
{
	return(S.top-S.base);
}

//判断栈是否为空
bool IsEmpty(SqStack &S)
{
	if(S.top == S.base)//空 
		return true;
	else
		return false;
}

void DestoryStack(SqStack &S)
{
	if(S.base)
	{
		delete(S.base);
		S.base = NULL;
		S.top = NULL;
		cout<<endl<<"销毁成功!";
	}else
		cout<<"\n销毁失败!";
}

void Test()
{
int num,x;
	
	SqStack S;
	
	//1.初始化栈 
	InitStack(S);
	
	//2.元素的插入
	cout<<"请输入插入元素的个数:"<<endl;
	cin>>num;
	
	printf("依次输入%d个元素:",num);
	while(num>0)
	{
		cin>>x;
		PushStack(S,x);
		num--;
	}
	
	cout<<"\n依次出栈结果如下:"<<endl;
	
	//3.获取栈顶元素并出栈    
	while(!IsEmpty(S))
	{
		cout<<GetTop(S)<<"  ";//输出栈顶元素
		PopStack(S,x);//栈顶元素出栈 
	}
	cout<<endl;
	
	DestoryStack(S);
}
int main()
{
	Test();
	return 0; 
}

12.运行结果

在这里插入图片描述
如果只是想单纯的查看栈中的元素，而不要元素出栈的方式可以借鉴“闵版的顺序存储方式”。“钦版的顺序存储是采用双指针”，一般出栈即删除。

三、钦版（链式存储）

1.结构体的创建

typedef struct _StackNode
{
	int data;
	struct _StackNode *next;
}Node,*NodePtr;

2.初始化栈

/*初始化栈*/
bool InitStack(NodePtr &Top)
{

	Top = new struct _StackNode;
	Top->next = NULL;

	return true;
}

3.元素压栈

/*元素压栈*/
bool Push_Stack(NodePtr &Top,int e)
{
	NodePtr p = new _StackNode;

	if(!p)
		return false;

	p->data = e;//给此结点数据域赋值为e
	p->next = Top->next;//新结点的指针域指向原来倒数第二个
	Top->next = p;    //栈顶指针指向新的结点

	return true;
}

在这里插入图片描述

4.按任意位置压栈

/*按任意位置插入*/
bool insert_Stack(NodePtr &Top,int pos,int val)
{
	NodePtr pMove = Top,q;

	int i = 0;

	/*如果是在第一个插入那么和压栈一样，那就直接采用压栈的方式吧*/
	if(pos == 1)
	{
		if(Push_Stack(Top,val))
			return true;
		else
			return false;
	}

	while(pMove && i<pos-1)
	{
		pMove = pMove->next;
		i++;
	}

	if(i>pos-1 || !pMove)
	{
		cout<<"非法插入!"<<endl;
		return false;
	}

	NodePtr pNew = new _StackNode;
	pNew->data = val;
	q = pMove->next;//指向插入点的位置
	pMove->next = pNew;//更新pMove->next为新的结点
	pNew->next = q;//新的结点指向原来pMove->next的指向

	return true;

}

在这里插入图片描述

5.出栈

/*出栈*/
bool Pop_Stack(NodePtr &Top,int &e)
{
	if(!Top->next)
		return false;

	NodePtr p;

	p = Top->next;
	e = p->data;
	Top->next = p->next;

	delete p;

	return true;
}

在这里插入图片描述

6.获取栈顶元素

/*获取栈顶元素*/
bool GetTop(NodePtr &Top,int &e)
{
	if(Top->next == NULL)
	{
		cout<<"栈顶为空！"<<endl;
		return false;
	}

	e = Top->next->data;
}

7.获取栈长

/*获取栈长*/
int Get_Length(NodePtr &Top)
{
	int num = 0;
	NodePtr pMove = Top->next;

	while(pMove != NULL)
	{
		num++;
		pMove = pMove->next;
	}
	return num;
}

8.摧毁链栈

/*摧毁链栈*/
void Destory_Stack(NodePtr &Top)
{
	if(Top)
	{
		delete Top;
		cout<<endl<<"摧毁成功!"<<endl;
	}else
		cout<<endl<<"摧毁出错!"<<endl;
}

9.完整代码

#include <iostream>

using namespace std;

typedef struct _StackNode
{
	int data;
	struct _StackNode *next;
}Node,*NodePtr;

/*初始化栈*/
bool InitStack(NodePtr &Top)
{

	Top = new struct _StackNode;
	Top->next = NULL;

	return true;
}

/*元素压栈*/
bool Push_Stack(NodePtr &Top,int e)
{
	NodePtr p = new _StackNode;

	if(!p)
		return false;

	p->data = e;//给此结点数据域赋值为e
	p->next = Top->next;//新结点的指针域指向原来倒数第二个
	Top->next = p;    //栈顶指针指向新的结点

	return true;
}

/*打印*/
void Print_Stack(NodePtr &Top)
{
	NodePtr pMove = Top->next;

	if(!pMove)
		return;

	cout<<"链栈打印结果如下:"<<endl;
	while(pMove != NULL)
	{
		cout<<pMove->data<<" ";
		pMove = pMove->next;
	}

	cout<<endl;
	return;
}

/*出栈*/
bool Pop_Stack(NodePtr &Top,int &e)
{
	if(!Top->next)
		return false;

	NodePtr p;

	p = Top->next;
	e = p->data;
	Top->next = p->next;

	delete p;

	return true;
}


/*获取栈顶元素*/
bool GetTop(NodePtr &Top,int &e)
{
	if(Top->next == NULL)
	{
		cout<<"栈顶为空！"<<endl;
		return false;
	}

	e = Top->next->data;
}

/*获取栈长*/
int Get_Length(NodePtr &Top)
{
	int num = 0;
	NodePtr pMove = Top->next;

	while(pMove != NULL)
	{
		num++;
		pMove = pMove->next;
	}
	return num;
}

/*摧毁链栈*/
void Destory_Stack(NodePtr &Top)
{
	if(Top)
	{
		delete Top;
		cout<<endl<<"摧毁成功!"<<endl;
	}else
		cout<<endl<<"摧毁出错!"<<endl;
}
void Test()
{
	NodePtr S = NULL;

	//1.初始化
	if(InitStack(S))
		cout<<"初始化成功！！"<<endl<<endl;

	//2.压栈
	int len = 0;
	cout<<"请输入压栈的次数:";
	cin>>len;
	cout<<"请输入压栈元素:";
	for(int i=0;i<len;i++)
	{
		int data;
		cin>>data;
		Push_Stack(S,data);
		Print_Stack(S);
	}

	//3.获取栈顶元素
	int top_data = -1;
	GetTop(S,top_data);
	cout<<endl<<"栈顶元素为:"<<top_data<<endl;

	//4,获取栈长
	int length =Get_Length(S);
	cout<<"栈长为:"<<length<<endl;

	//5.出栈
	int num = 0;
	cout<<endl<<"请输入出栈次数:";
	cin>>num;

	for(int i = 0;i<num;i++)
	{
		int node;
		 Pop_Stack(S,node);
		cout<<endl<<"删除"<<node<<"成功！"<<endl;
		Print_Stack(S);
	}

	//6.摧毁链栈
	Destory_Stack(S);
}

int main()
{
	Test();
	system("pause");
}

10.运行结果

在这里插入图片描述
在这里插入图片描述

四、总结

1.栈有顺序存储和链式存储两种方式。
2.顺序存储里也含有单指针和双指针两种结构方式。
3.构建栈结构，主要是要注意栈先进后出，后进先出的特性。

C++New不出对象
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
顺序存储和链式存储的泛型队列_C语言项目
04-12
本项目专注于实现顺序存储和链式存储的泛型队列，使用C语言作为编程工具，旨在提供灵活且高效的操作接口。下面我们将深入探讨相关知识点。 首先，队列是一种先进先出（First In First Out, FIFO）的数据结构，它的...
链式存储二叉树基本操作函数.rar
03-28
这些基本操作是理解和操作链式存储二叉树的关键。通过实现这些函数，我们可以有效地处理各种基于二叉树的问题，例如搜索、排序、数据结构构建等。在实际应用中，链式存储二叉树广泛应用于编译器设计、文件系统、...
栈的存储——顺序存储与链式存储
qq_45965736的博客
09-21 1748
根据栈的存储方式不同，我们学习顺序栈和链栈。并在代码逻辑中掌握这些操作。栈的插入，删除，判空等操作。顺序栈的优缺点，以及共享栈的提出。
栈和队列的顺序和链式存储结构
姜守威的博客
12-04 2344
栈和队列 栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。 栈的顺序存储结构 typedef struct { ElemType *base; // 指向栈底的指针变量 ElemType *top; // 指向栈顶的
栈的定义，顺序存储和链式存储
m0_65560240的博客
09-16 435
一.栈的定义 栈：是只允许在一端进行插入或删除操作的线性表。 二.栈的存储方式有两种： 顺序栈和链栈，即栈的顺序存储和链式存储。 1.采用顺序存储的栈称为顺序栈，它利用一组地址连续的存储单元存放自栈底到栈的元素，同时附设一个指针（top）指示当前栈顶的位置。\n2.采用链式存储的栈称为链栈，链栈便于多个栈共享存储空间和提高其效率，且不存在栈满上溢的情况。通常采用单链表实现，并且所有操作都是在单链表的表头进行的 三.栈道基本操作 //判栈空 bool Empty(SqStack S){
顺序存储和链式存储有什么区别
weixin_42594419的博客
02-11 1667
顺序存储和链式存储是两种不同的数据存储方式。 顺序存储是将数据存储在连续的内存单元中，它的优点是查询快，因为通过下标可以直接访问内存中的数据。但缺点是插入和删除比较困难，因为需要移动大量的数据。 链式存储是将数据存储在若干个节点中，每个节点都存储了该数据以及下一个节点的地址信息。它的优点是插入和删除数据非常灵活，因为只需要修改与该节点相关的地址信息。但缺点是查询比较慢，因为需要遍历整个链表才能找到...
链式存储与顺序存储的区别
天射手座的博客
01-14 6953
一、存储地址 链式存储：储存单位的地址不一定是连续的 顺序存储：储存单位的地址必须是连续的 二、存储空间利用率与分配 链式存储：利用率低，动态分配 顺序存储：利用率高，静态分配 三、修改内容速度 链式存储：修改速度快 顺序存储：修改速度慢 三、查询内容速度 链式存储：查询速度慢 顺序存储：查询速度快 ...
23-栈的链式存储结构和基本运算实现
网络安全
06-13 961
1. 栈的链式存储结构   栈的链式存储结构也称为链栈，栈的链式存储结构本质上还是以线性表的链式存储来实现的，一般来说，链表有头指针，栈也有栈顶指针，那么可以把栈顶放在链表的头部，用头指针来表示栈顶指针，但是这里我们不用头结点存储栈顶节点，而是让头结点的next指针指向栈顶节点。 图1-栈的链式存储结构 栈的链式存储结构定义如下所示： //定义链栈的结点 typedef struc...
栈的顺序存储与链式存储
qq_43666632的博客
09-20 692
栈的顺序存储与链式存储
王道数据结构：栈顺序存储和链式存储以及基本操作的实现(C语言版）
知且行的博客
01-22 5355
栈 只允许在一端进行插入或删除操作的线性表。 对于n个不同元素进栈，出栈序列的个数为(卡特兰数) 顺序栈基本操作的实现代码如下： #include <stdlib.h> #include <stdio.h> #include <math.h> #include <string.h> #define MaxSize 10 //栈的顺序存储...
顺序存储和链式存储
MeiLuan_yahoho的博客
02-03 2319
顺序存储和链式存储是存储结构，不是数据逻辑结构 顺序存储结构和链式存储结构的区别 链表存储结构的内存地址不一定是连续的，但顺序存储结构的内存地址一定是连续的； 链式存储适用于在较频繁地插入、删除、更新元素时，而顺序存储结构适用于频繁查询时使用。 顺序存储结构和链式存储结构的优缺点： 空间上 顺序比链式节约空间。是因为链式结构每一个节点都有一个指针存储域。 存储操作上： 顺序支持随机存取，方便操作 ...
二叉树的存储结构顺序存储和链式存储
KingOfMyHeart的博客
05-16 2939
顺序存储 实现：将一棵二叉树按照当做一棵满二叉树进行编号（从上到下，从左到右），编号作为数组的下标，一次存放到二叉树的数据元素。 当一个二叉树不是完全二叉树，那么总会有一些位置没有元素，那么就将这些位置空出来。 #define CAPACITY typedef TElemType SqBinaryTree[CAPACITY]; SqBinaryTree sb; 将下表恢复成一棵二叉树： 如图，空着的地方对应没有数据： 缺点： 浪费储存空间，只有左孩子或者只有右孩子的情况更加明显，更适用于满二叉树或者
C语言中栈的顺序存储和链式存储
10-12
C语言中栈的顺序存储和链式存储
3.3栈的链式存储
09-27
### 栈的链式存储详解 #### 一、栈的链式存储思想 在计算机科学领域，栈（Stack）是一种非常重要的线性数据结构之一，它遵循“后进先出”（Last In First Out, LIFO）的原则进行数据的操作。栈的实现方式有两种...
线性表的顺序存储结构、链式存储结构上的基本操作
12-19
在本主题中，我们将深入探讨线性表的两种主要存储结构：顺序存储结构和链式存储结构，以及在这两种结构上实现的基本操作。同时，我们还会涉及栈这种特殊类型的线性表及其顺序和链式存储结构。 一、线性表的顺序存储...
学习记录day18——数据结构 算法
最新发布
weixin_64918301的博客
07-24 899
程序 = 数据结构 + 算法算法是程序设计的灵魂，结构式程序设计的肉体算法：计算机解决问题的方法护额步骤。
数据结构之《栈》
2303_81098358的博客
07-24 1287
在之前我们已经学习了数据结构中线性表里面的顺序表与链表，了解了如何实现顺序表与链表增、删、查、该等功能。其实在线性表中除了顺序表和链表还有其他的类别，在本篇中我们就将学习另外一种线性表——栈，在通过本篇的学习后，你将会对栈的结构有充足的了解，在了解完结构后我们还将进行栈的实现。
【数据结构】：用Java实现链表
Yechiel的博客
07-24 1361
本篇文章用Java介绍了：链表的概念，以及单链表的主要功能的具体实现方法
数据结构——双向链表及其总结
2406_83392683的博客
07-23 425
1.概述链表根据是否带头、是否双向、是否循环可以分为八种，双向链表是典型的带头双向循环链表。2.双向链表的实现过程及其解析双向链表的实现依旧包含List.h，List.c，test.c2.1 链表初始化双向链表为空的情况：只有一个哨兵位。2.2插入数据。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值