自构建栈类（数组和链表双实现方式）

最新推荐文章于 2024-05-10 12:44:18 发布
最新推荐文章于 2024-05-10 12:44:18 发布
阅读量173 收藏
点赞数 1
分类专栏： 数据结构 文章标签： 链表 数据结构 c++ 栈
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43727225/article/details/108830842
版权

东软学习小组成员：夜枫
最近学习数据结构与算法，讲到链表和栈，为了满足自己的好奇心和小小的成就感还有巩固知识，便根据栈的特点和功能，自构建栈类（分别使用数组和链表实现)

在用链表实现时发现用结构体老是报错有问题，想到类本身就是结构体的演化，而且占据的内存是一样的，为什么要执着于用结构体呢，
带着想法度娘了一下，发现这篇博客就是用的类模板，所以验证了心里的想法用类来代替结构体，
因知单纯看书看别人的代码是不够的，自己敲出来的才是自己的，所以把自己写的代码分享出来，也方便以后查看回忆

/**
构建栈，并完善栈的各项操作，
1，判空
2，判断栈的长度，
3.插入，取出
4.栈顶的元素 
5.栈中的元素个数
*/

数组实现

/**
构建栈，并完善栈的各项操作，

1，判空
2，判断栈的长度，
3.插入，取出
4.栈顶的元素 
5.是否有最长度元素 


*/
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
template<class T>
class mystack{
	private:
		
		int top;
	    int maxn;
		T *data;
	public:
		mystack(){
			top=-1;
			maxn=100;
			data=new T(maxn);
			memset(data,0,sizeof(data));
		}
		bool isEmpty(){
			return top==-1;
		}
		bool isFull(){
			return top==maxn-1;
		}
		bool push(T temp){
			if(top<maxn){
			//	cout<<"top="<<top<<endl;
				data[++top]=temp;
			//	cout<<"出入成功"<<data[top]<<"成功"<<endl;
				return true;
			}
			return false;
		}
		
		T pop(){
			T t=data[top];
			data[top]=0;
			top--;
			return t;
		}
		T gettop(){
		//	cout<<"gettop="<<data[top]<<endl;
			T t=data[top];
			return t;
		}
		~mystack(){
			delete data;
		}
};
int main(){
	mystack<int> s;
	cout<<s.isEmpty()<<endl;
	cout<<s.isFull()<<endl;
	
	int a=100;
	int b=200;
	s.push(a);
	cout<<"top1="<<s.gettop()<<endl;
	s.push(b);
	cout<<"top2="<<s.gettop()<<endl;
	cout<<"pop1="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	cout<<"pop2="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	return 0;
}

2.单向链表是实现：

#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
template<class T>
class Node{
private:
	T data;
	Node *pre;
public:
	Node(){}
	Node(T t,Node* _pre){
		data = t;
		pre = _pre;
	}

	T getData(){
		return data;
	}
	void setData(T t){
		data = t;
	}
	Node* getPre(){
		return pre;
	}
	void setPre(Node *_pre){
		pre = _pre;
	}
	~Node(){
//		cout<<"\n执行析构函数Node"<<endl;
	}

};



template<class T>
class mystack2{
private:
	Node<T>* top;
	Node<T>* Temp;
public:
	mystack2(){
		top = NULL;
		Temp = NULL;

	}
	bool isEmpty(){
		return top == NULL;
	}
	bool isFull(){
		return top != NULL;
	}
	bool push(T temp){
			Temp = new Node<T>(temp, NULL);
			if (top != NULL){
				Temp->setPre(top);
			}
			top = Temp;
			return true;
	}

	T pop(){
		T t = top->getData();

		Temp = top;
		top = top->getPre();
		delete Temp;

		return t;
	}
	T gettop(){
		T t = top->getData();
		return t;
	}
	~mystack2(){
	//	cout<<"delete->"<<top->getData();
	//	cout<<"\n执行析构函数mystack2"<<endl; 
			while (top)
			{
			//	cout<<"delete->"<<top->getData()<<endl;
				Temp = top;
				top = top->getPre();
		//		cout<<"delete->"<<top->getData();
				delete Temp;

			}

		


		if (Temp){

			delete Temp;
			Temp=NULL;
		}
		if (top){

				delete top;
				top=NULL;
		}
	}
};

int main(){
	mystack2<int> s;
	cout<<s.isEmpty()<<endl;
	cout<<s.isFull()<<endl;
	
	int a=100;
	int b=200;
	s.push(a);
	cout<<"top1="<<s.gettop()<<endl;
	s.push(b);
	cout<<"top2="<<s.gettop()<<endl;
	cout<<"pop1="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	cout<<"pop2="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;

	s.push(a);
	cout<<"top3="<<s.gettop()<<endl;
	s.push(b);
	s.push(a);
	s.push(b);


	return 0;
}

如果看不懂可以看下面带注释的
1.数组实现：`

/**
构建栈，并完善栈的各项操作，

1，判空
2，判断栈的长度，
3.插入，取出
4.栈顶的元素 
5.是否有最长度元素 


*/
#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
template<class T>
class mystack{
	private:
		int top;
	    int maxn;
		T *data;
	public:
		//初始化 
		mystack(){
			top=-1;
			maxn=100;//默认栈的最多100个元素 
			//分配数组内存 //销毁要用delete data 
			data=new T(maxn);
			memset(data,0,sizeof(data));//初始化数组 
		}
		//判断栈是否为空，若栈顶为-1，为空，否则为真 
		bool isEmpty(){
			return top==-1;
		}
		//判断是否 
		bool isFull(){
			return top==maxn-1;//如果栈现在是99 0-99为100个，满了 
		}
		//压入元素到栈，压栈 
		bool push(T temp){
			//如果栈未满则压栈 ，返回真，否则假 
			if(top<maxn){
				data[++top]=temp;
				return true;
			}
			return false;
		}
		//出栈 
		T pop(){
			T t=data[top];
			data[top]=0;//改未初始化 
			top--;//栈顶减1 
			return t;
		}
		//单纯得到栈顶数值 
		T gettop(){
		//	cout<<"gettop="<<data[top]<<endl;
			T t=data[top];
			return t;
		}
		//栈中有多少个元素 
		int length(){
			return top+1;//栈顶的下标就是个数-1 
		} 
		~mystack(){
			delete data;
		}
};
int main(){
	mystack<int> s;
	cout<<s.isEmpty()<<endl;
	cout<<s.isFull()<<endl;
	
	int a=100;
	int b=200;
	s.push(a);
	cout<<"top1="<<s.gettop()<<endl;
	s.push(b);
	cout<<"top2="<<s.gettop()<<endl;
	cout<<"pop1="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	cout<<"pop2="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	return 0;
}

2.链表实现：

#include<iostream>
#include<string.h>
#include<stdlib.h>
using namespace std;
//采用模板类节点 ，结构体总是不知道啥毛病，老报错 
template<class T>
class Node{
private:
	T data;//数据 
	//节点的上一个节点，往栈底方向，如果本节点的前驱节点为空，则本节点为栈的最后一个节点
	Node *pre; 
public:
	Node(){}
	Node(T t,Node* _pre){
		data = t;
		pre = _pre;
	}

	T getData(){
		return data;
	}
	void setData(T t){
		data = t;
	}
	Node* getPre(){
		return pre;
	}
	void setPre(Node *_pre){
		pre = _pre;
	}
	~Node(){
//		cout<<"\n执行析构函数Node"<<endl;
	}

};



template<class T>
class mystack2{
private:
	Node<T>* top;//定义栈顶节点 
	Node<T>* Temp;//定义中间节点 
public:
	mystack2(){//初始化 
		top = NULL;
		Temp = NULL;
	}
	//判空 
	bool isEmpty(){
		return top == NULL;
	}
	
	
//因压栈和出栈均动态变化并且不会造成内存浪费，故此实现决定不考虑栈的节点上限  
	
//	//判断是否 满了，
	bool isFull(){//一直不满 
		return false; 
	}
	//压栈 
	bool push(T temp){
			Temp = new Node<T>(temp, NULL);//分配内存 ，并设置数据，前驱为空 
			//如果栈顶存在，即栈里本来有节点，则次节点的前驱指向栈顶 
			if (top != NULL){
				Temp->setPre(top);
			}
			
			//新压入的节点为栈顶 
			top = Temp;//更新栈顶 
			return true;
	}
	//出栈 
	T pop(){
		T t = top->getData();//取出栈顶的值 
		Temp = top;//临时保存 
		top = top->getPre();//出栈后，栈顶的前驱变为栈顶 
		delete Temp;//销毁栈顶 

		return t; 
	}
	//得到栈顶的数据 
	T gettop(){
		T t = top->getData();
		return t;
	}
	//析构函数 
	~mystack2(){
	//	cout<<"\n执行析构函数mystack2"<<endl; 
	
	//当栈顶不为空 
			while (top)
			{
				//取出栈顶， 
				
				Temp = top;
				//更新栈顶 
				top = top->getPre();
				delete Temp;//销毁栈顶 

			}

		

		//最后判断 
		if (Temp){

			delete Temp;
			Temp=NULL;
		}
		if (top){

				delete top;
				top=NULL;
		}
	}
};

int main(){
	mystack2<int> s;
	cout<<s.isEmpty()<<endl;
	cout<<s.isFull()<<endl;
	
	int a=100;
	int b=200;
	s.push(a);
	cout<<"top1="<<s.gettop()<<endl;
	s.push(b);
	cout<<"top2="<<s.gettop()<<endl;
	cout<<"pop1="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;
	cout<<"pop2="<<s.pop()<<endl;
	cout<<"isempty? "<<s.isEmpty()<<endl;

	s.push(a);
	cout<<"top3="<<s.gettop()<<endl;
	s.push(b);
	s.push(a);
	s.push(b);


	return 0;
}
夜枫之家
关注
专栏目录
用数组实现链表、栈和队列
⚡
01-26 1243
详解用数组实现单链表、双链表、栈和队列
栈的构建
今天是个好天气~
06-14 494
class MyStack { private: int m_size; int m_top; char *m_pStack; public: MyStack::MyStack(int _size):m_size(_size),m_top(0){ m_pStack=new char[_size]; } MyStack::~MyStack(){ delete []m_pStack; m
使用链表结构构建栈结构
qq_15718789的博客
10-06 782
在所熟悉的栈结构和队列结构中，使用数组存储数据的方式非常简单，但一旦在插入和删除操作时就会显得很吃力了，而使用链表结构，虽然会导致后面或者前面的数据位子发生变动，却显得花费轻松了很多，所以学习链表结构就显得尤为的重要，而对应关系也是的链表结构成为了大多程序员愿意选择的一种方式。链表结构有两种，一种是静态的，说的是确定了链表长，往里面添加数据就可以了，可能要求考虑满的情况，不利于数据的动态添加和维护
使用队列构建栈(两种方法）
mtj295152的博客
07-19 268
问题关键在于push，双队列解决push的方法就是始终让一个队列保持为空，另一个队列保持栈的先进后出的排放。在一个新元素进栈时，让新元素进入空队列，然后按照栈的顺序依次让另一个队列的元素放入空队列。使用一个队列的方法和第一种方法略有不用，但道理差不多即是让队列中的元素保持先进后出。因此我们在放入一个新元素时，为了让新元素先出，新元素的位置必须是front。二、第二种方法使用一个队列。一、第一方法使用两个队列。...
C++实现栈的基本操作
专业^团队的博客
05-07 500
#include<cstdio> #include<cstdlib> #include<cstring> #include<cmath> #include<iostream> using namespace std; #define Status int #define SElemType int #define MaxSize 100 //栈数据结构 typedef struct Stack { SElemType* base;//栈底指针 .
数据结构：超详细！创建链栈及其基本操作（C语言）
qq_44131760的博客
04-08 2070
链栈顾名思义就是用把链表改造一下，用于实现栈。 栈的核心要点： 1.怎么实现栈先进先出的特性？ 这个特性用单链表来实现，那就只在单链表的一端插入或删除单元即可。比如把尾节点当作栈底，往尾节点前面插入或者删除元素。 2.怎么体现压栈操作？ 需要存储数据的时候，创建新单元存储这个数据并链接到已创建的链表上。 3.怎么体现出栈操作？ 访问栈顶单元，取出数据以后，销毁该单元，即完成出栈操作 代码： #in...
线性表 - 栈（数组和链表两种方式实现栈）
云梦归遥【qq_45834685】
05-12 888
线性表 - 栈（数组和链表两种方式实现栈）
【数据结构】栈的实现以及数组和链表的优缺点
最新发布
2303_80187476的博客
05-10 2787
如果数据已经在缓存中（缓存命中），那么CPU就可以直接从缓存中读取数据，而不需要从主存中读取，从而提高了程序的运行效率。由于数组的物理地址是连续的，因此数组中的数据在缓存中的命中率更高，减少了从主存中读取数据的次数，从而提高了缓存利用率。但是，链表的节点在物理存储上是不连续的，因此链表中的数据在缓存中的命中率相对较低。在访问一块数据内存空间时，要先把内存加载到缓存，在对其进行访问，而其并不是没此访问一个内存就将其加载到缓存，而是访问一块内存时将其后面的连续的内存一起加载到缓存，然后在对其进行访问。
利用一个链表类实现一个队列类和栈类.rar_栈 链表 c++ _链表 类_链表类_队列 类_队列类
09-19
在提供的“利用一个链表类实现一个队列类和栈类.doc”文档中，可能包含了以下内容：链表类的定义，包括节点结构和链表的基本操作（如初始化、添加节点、删除节点等）；栈类的实现，包括压栈和弹栈的方法；队列类的...
基于JAVA实现的常用数据结构代码，JAVA实现复杂度、动态数组、链表、栈、队列、二叉搜索树等
01-04
另一种实现方式是使用ArrayList或LinkedList。 5. **队列**：队列是一种先进先出（FIFO）的数据结构，适用于处理等待执行的任务。Java提供了多种队列实现，如ArrayDeque、LinkedList（通过其offer、poll方法）等。...
Python实现栈的方法详解【基于数组和单链表两种方法】
12-20
在Python中，可以创建一个`Node`类来表示链表节点，然后在`Stack`类中使用这个节点来构建链表。单链表栈的`push`操作是在链表头部插入新节点，`pop`操作则是删除链表头部的节点。这里是一个简单的单链表栈实现： ``...
go的基础数据结构的实现，包括动态数组、链表、堆、栈、集合、索引、二分搜索树、avl数、红黑树等.zip
01-03
这个名为"go的基础数据结构的实现，包括动态数组、链表、堆、栈、集合、索引、二分搜索树、avl树、红黑树等.zip"的压缩包提供了一系列用Go实现的数据结构的源代码。下面将详细探讨这些数据结构的原理及其在Go中的...
7-23 公路村村通 (30分)
夜枫之家的博客
12-12 918
现有村落间道路的统计数据表中，列出了有可能建设成标准公路的若干条道路的成本，求使每个村落都有公路连通所需要的最低成本。 输入格式: 输入数据包括城镇数目正整数N（≤1000）和候选道路数目M（≤3N）；随后的M行对应M条道路，每行给出3个正整数，分别是该条道路直接连通的两个城镇的编号以及该道路改建的预算成本。为简单起见，城镇从1到N编号。 输出格式: 输出村村通需要的最低成本。如果输入数据不足以保证畅通，则输出−1，表示需要建设更多公路。 输入样例: 6 15 1 2 5 1 3 3 1 4 7 1 5 4
7-33 阅览室 (20分)
夜枫之家的博客
12-25 821
东软小组: 烈焰 天梯图书阅览室请你编写一个简单的图书借阅统计程序。当读者借书时，管理员输入书号并按下S键，程序开始计时；当读者还书时，管理员输入书号并按下E键，程序结束计时。书号为不超过1000的正整数。当管理员将0作为书号输入时，表示一天工作结束，你的程序应输出当天的读者借书次数和平均阅读时间。 注意：由于线路偶尔会有故障，可能出现不完整的纪录，即只有S没有E，或者只有E没有S的纪录，系统应能...
PTA 7-18 二叉树的广度优先遍历 (10分)
夜枫之家的博客
06-04 519
东软学习小组成员：夜枫 题目： 创建一颗二叉树，并进行广度优先遍历 输入格式: abd##e##cf###，#代表空节点 输出格式: 按广度优先顺序输出，两个字符间有一个空格 输入样例: 在这里给出一组输入。例如： abd##e##cf### 输出样例: 在这里给出相应的输出。例如： 注意：最后一个没有空格 a b c d e f 1.构建结构体 struct node { char data; node* left; node* right; }; typedef node* Node;//节点
Connect the Cities（连接城市）
夜枫之家的博客
12-12 518
@author:yefeng In 2100, since the sea level rise, most of the cities disappear. Though some survived cities are still connected with others, but most of them become disconnected. The government wants to build some roads to connect all of these cities again
Dijkstra算法各种实现
夜枫之家的博客
10-26 506
首先了解下什么是最短路径算法-----Dijkstra算法详解 来一条传送门-> 最短路径问题—Dijkstra算法详解 看到这里相信你已经知道了Dijkstra算法的大致思路 先直接上代码 第一种实现，用队列实现，优化 //start 起点，len点集个数，map 地图的二维数组，dis 起点到其的距离 void dijkstra(int start,int len,int map[][N],int dis[]){ int vis[len]; queue<int>q;//队列，存剩余
查找最接近的元素
夜枫之家的博客
07-24 495
在一个非降序列中，查找与给定值最接近的元素。 Input 第一行包含一个整数n，为非降序列长度。1 <= n <= 100000。 第二行包含n个整数，为非降序列各元素。所有元素的大小均在0-1,000,000,000之间。 第三行包含一个整数m，为要询问的给定值个数。1 <= m <= 10000。 接下来m行，每行一个整数，为要询问最接近元素的给定值。所有给定值的大小均在0-1,000,000,000之间。 Output m行，每行一个整数，为最接近相应给定值的元素值，保持输入顺
7-11 小字辈 (25分)
夜枫之家的博客
05-27 445
东软学习小组成员：夜枫 本题给定一个庞大家族的家谱，要请你给出最小一辈的名单。 输入格式： 输入在第一行给出家族人口总数 N（不超过 100 000 的正整数） —— 简单起见，我们把家族成员从 1 到 N 编号。随后第二行给出 N 个编号，其中第 i 个编号对应第 i 位成员的父/母。家谱中辈分最高的老祖宗对应的父/母编号为 -1。一行中的数字间以空格分隔。 输出格式： 首先输出最小的辈分（老祖宗的辈分为 1，以下逐级递增）。然后在第二行按递增顺序输出辈分最小的成员的编号。编号间以一个空格分隔，行首尾不得
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值