栈的链表实现

最新推荐文章于 2024-04-27 17:11:19 发布
最新推荐文章于 2024-04-27 17:11:19 发布
阅读量1.7k 收藏 5
点赞数 3
文章标签： c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1291714103/article/details/124607292
版权

栈的抽象类

template <class Type>
class stackADT
{
public:
	virtual void initializeStack() = 0;
	virtual bool isEmptyStack()const = 0;
	virtual bool isFullStack()const = 0;
	virtual void push(const Type&) = 0;
	virtual void pop() = 0;
	virtual Type top()const = 0;
};

抽象类只给出最基本的方法，没有函数实现。

节点

template<class Type>
struct node
{
	Type info;
	node<Type>* next;
};

用struct定义节点的好处在于不用管构造函数，结构体里只放变量，而且这里struct也是个模板，可以适应不同的元素类型。

链栈类

template<class Type>
class linkStack :public stackADT<Type>
{
public:
	void initializeStack();
	bool isEmptyStack()const;
	bool isFullStack()const;
	void push(const Type&);
	void pop();
	Type top()const;
	linkStack();
	linkStack(const linkStack<Type>&);
	~linkStack();
	const linkStack<Type>& operator=(const linkStack<Type>&);
private:
	node<Type>* stackTop;
	void copyStack(const linkStack<Type>&);
};

链栈继承了抽象栈的基本方法，我们要表示一个链栈只需要一个指向栈顶的指针就行了。

成员函数表

函数名函数功能
void isEmptyStack()const判断栈是否为空
void isFullStack()const判断栈是否已经满
void initializeStack()初始化栈
void pop()弹出一个元素
void push(const Type&)将元素压入栈中
Type top()const返回栈顶元素
linkStack()构造函数
void copyStack(const linkStack&)实现栈的复制操作
linkStack(const linkStack&)拷贝构造函数
~linkStack()析构函数
const linkStack& operator=(const linkStack&)重载赋值符

成员函数实现

linkStack()

对于一个类而言我们首先要考虑的就是其构造函数如何设计，第一个问题就来了，到底要不要在构造函数生成节点？并不需要，这和数组实现的栈不同，数组栈构造函数会开辟一段内存，而链栈只要让栈顶指针为空就好了。

代码如下：

template<class Type>
linkStack<Type>::linkStack()
{
	stackTop = nullptr;
}

void isEmptyStack()const

判断链栈是否为空很简单，和数组栈类似，数组栈是看栈元素个数是否为0，链栈则是看栈顶指针是否为空。

代码如下：

template<class Type>
bool linkStack<Type>::isEmptyStack()const
{
	return stackTop == nullptr;
}

void isFullStack()const

对于链栈来说理论上是永远不会满的，除非电脑内存不够了，这时会自动报错，因此返回值永远是0。

代码如下：

template<class Type>
bool  linkStack<Type>::isFullStack()const
{
	return 0;
}

void initializeStack()

链栈的初始化要分两种情况，第一种就是栈中有节点存在，这时就要依次释放节点的内存，然后把栈顶指针置为空。另外一种就是栈中无节点，由于构造函数已经把栈顶指针置为空，所以无需进行操作。不像数组栈初始化那么简单只需要把表示栈中元素个数的变量置为0就可以了。

代码如下：

template<class Type>
void linkStack<Type>::initializeStack()
{
	while (stackTop)
	{
		node<Type>* temp = stackTop;
		stackTop = stackTop->next;
		delete temp;
	}
}

void pop()

链栈弹出一个节点需要释放该节点的内存，然后让栈顶指针指向后一个节点就可以了，但是栈为空的情况要额外考虑，栈为空就在控制台输出提示信息。

代码如下：

template<class Type>
void linkStack<Type>::pop()
{
	if (isEmptyStack())
	{
		cout << "The stack is empty,cannot pop" << endl;
	}
	else
	{
		node<Type>* temp;
		temp = stackTop;
		stackTop = stackTop->next;
		delete temp;
	}
}

void push(const Type&)

将元素压入栈中，这里得考虑一个点那就是我们到底是把一个节点作为push的输入还是把元素作为push的输入，对于使用者来说我才不管你这个数据结构内部是怎么写的，链栈也好，数组栈也罢其作为栈的功能都是一样的，只不过实现方式不同，那么对于使用者来说有的肯定是元素类型，如果还要自己建立一个node那不是很麻烦了，所以我们这里把元素直接作为输入。
因为压入栈中的是元素，所以我们得新建一个节点，然后把元素放入节点中，再让该节点变成栈的栈顶节点。链栈有个好处就是压栈不用考虑栈满的情况。

代码如下：

template<class Type>
void linkStack<Type>::push(const Type& info)
{
	node<Type>* newNode = new node<Type>;
	newNode->info = info;
	newNode->next = stackTop;
	stackTop = newNode;
}

Type top()const

同push函数，top函数的不是返回节点的地址而是直接返回元素，这与使用者的期望是符合的，top函数也需要做异常处理，因为该函数是有返回值的，所以一旦遇到空栈的情况我们就要终止程序，而不能仅仅在控制台上输出异常信息。
函数实现很简单，直接返回栈顶指针的元素就行了。

代码如下：

template<class Type>
Type linkStack<Type>::top()const
{
   assert(!isEmptyStack());
   return stackTop->info;
}

void copyStack(const linkStack&)

这个函数的功能就是实现链栈的拷贝，你也许会问这不是拷贝构造函数要解决的问题吗？实际上拷贝构造函数内会调用该函数，在这里触发拷贝构造函数只有两种情况，即链栈作为函数的输入或者输出参数时，而第三种情况的处理则丢给了=运算符重载。
拷贝过程首先要判断当前链栈是否为空，若非空则要将栈初始化。然后看被拷贝的栈是否为空，如果空则令当前栈的栈顶指针为空；否则进入拷贝过程，我们设置三个指针，其中两个用来推进拷贝过程，指向当前拷贝与被拷贝的节点，另外一个则用来生成新节点。我们不要立马进入循环，注意此时栈顶指针是空的，所以我们先要拷贝第一个节点，让栈顶指针指向该节点，然后就可以进入循环了不断拷贝了。

代码如下：

template<class Type>
void linkStack<Type>::copyStack(const linkStack<Type>& otherStack)
{
	if (stackTop != nullptr)
	{
		initializeStack();
	}
	if(otherStack.isEmptyStack())
	{
		stackTop=nullptr;
	}
	else
	{
		stackTop = new node<Type>;
		stackTop->info = otherStack.stackTop->info;
		node<Type>* temp, * otherTemp;
		temp = stackTop;
		otherTemp = otherStack.stackTop->next;
		while (otherTemp)
		{
			node<Type>* newNode = new node<Type>;
			newNode->info = otherTemp->info;
			temp->next = newNode;
			temp = temp->next;
			otherTemp = otherTemp->next;
		}
		temp->next = nullptr;
	}
}

linkStack(const linkStack&)

拷贝构造函数，因为这里拷贝构造函数只在函数输入和输出的备份操作才会触发，所以是不会触发构造函数的，也就是说栈顶指针是个野指针，所以在拷贝构造函数中我们要把栈顶指针置为空，然后调用copyStack函数就行了。

代码如下：

template<class Type>
linkStack<Type>::linkStack(const linkStack<Type>& otherStack)
{
	stackTop = nullptr;
	copyStack(otherStack);
}

~linkStack()

一旦涉及到动态内存分配，析构函数就要释放内存，直接调用初始化函数即可。

代码如下:

template<class Type>
linkStack<Type>::~linkStack()
{
	initializeStack();
}

const linkStack& operator=(const linkStack&)

重载=运算符需要注意的一点就是要避免自我赋值，然后直接调用copyStack函数即可

代码如下：

template<class Type>
const linkStack<Type>& linkStack<Type>::operator=(const linkStack<Type>& otherStack)
{
	if (this != &otherStack)      //避免自我复制
		copyStack(otherStack);
	return *this;
}

全部代码

stackADT.h

template <class Type>
class stackADT
{
public:
	virtual void initializeStack() = 0;
	virtual bool isEmptyStack()const = 0;
	virtual bool isFullStack()const = 0;
	virtual void push(const Type&) = 0;
	virtual void pop() = 0;
	virtual Type top()const = 0;
};

linkStack.h

#include<iostream>
#include "stackADT.h"
#include<string>
#include<cassert>
using namespace std;
template<class Type>
struct node
{
	Type info;
	node<Type>* next;
};
template<class Type>
class linkStack :public stackADT<Type>
{
public:
	void initializeStack();
	bool isEmptyStack()const;
	bool isFullStack()const;
	void push(const Type&);
	void pop();
	Type top()const;
	linkStack();
	linkStack(const linkStack<Type>&);
	~linkStack();
	const linkStack<Type>& operator=(const linkStack<Type>&);
private:
	node<Type>* stackTop;
	void copyStack(const linkStack<Type>&);
};
template<class Type>
linkStack<Type>::linkStack()
{
	stackTop = nullptr;
}
template<class Type>
void linkStack<Type>::initializeStack()
{
	while (stackTop)
	{
		node<Type>* temp = stackTop;
		stackTop = stackTop->next;
		delete temp;
	}
}

template<class Type>
bool linkStack<Type>::isEmptyStack()const
{
	return stackTop == nullptr;
}

template<class Type>
bool  linkStack<Type>::isFullStack()const
{
	return 0;
}

template<class Type>
void linkStack<Type>::push(const Type& info)
{
	node<Type>* newNode = new node<Type>;
	newNode->info = info;
	newNode->next = stackTop;
	stackTop = newNode;
}

template<class Type>
void linkStack<Type>::pop()
{
	if (isEmptyStack())
	{
		cout << "The stack is empty,cannot pop" << endl;
	}
	else
	{
		node<Type>* temp;
		temp = stackTop;
		stackTop = stackTop->next;
		delete temp;
	}
}

template<class Type>
Type linkStack<Type>::top()const
{
	assert(!isEmptyStack());
	return stackTop->info;
}

template<class Type>
void linkStack<Type>::copyStack(const linkStack<Type>& otherStack)
{
	if (stackTop != nullptr)
	{
		initializeStack();
	}
	if (otherStack.isEmptyStack())
	{
		stackTop = nullptr;
	}
	else
	{
		stackTop = new node<Type>;
		stackTop->info = otherStack.stackTop->info;
		node<Type>* temp, * otherTemp;
		temp = stackTop;
		otherTemp = otherStack.stackTop->next;
		while (otherTemp)
		{
			node<Type>* newNode = new node<Type>;
			newNode->info = otherTemp->info;
			temp->next = newNode;
			temp = temp->next;
			otherTemp = otherTemp->next;
		}
		temp->next = nullptr;
	}
}

template<class Type>
linkStack<Type>::linkStack(const linkStack<Type>& otherStack)
{
	stackTop = nullptr;
	copyStack(otherStack);
}

template<class Type>
const linkStack<Type>& linkStack<Type>::operator=(const linkStack<Type>& otherStack)
{
	if (this != &otherStack)
		copyStack(otherStack);
	return *this;
}

template<class Type>
linkStack<Type>::~linkStack()
{
	initializeStack();
}

主函数（测试）

#include "linkStack.h"
#include<iostream>
using namespace std;
void testCopyConstructor(linkStack<int> otherStack);
int main()
{
	linkStack<int> stack;
	linkStack<int> copyStack;
	linkStack<int> dummyStack;
	stack.initializeStack();
	stack.push(23);
	stack.push(45);
	stack.push(38);
	copyStack.push(11);
	copyStack = stack; //copy stack into copyStack
	cout << "The elements of copyStack: ";
	while (!copyStack.isEmptyStack()) //print copyStack
	{
		cout << copyStack.top() << " ";
		copyStack.pop();
	}
	cout << endl;
	copyStack = stack;
	testCopyConstructor(stack); //test the copy constructor
	if (!stack.isEmptyStack())
		cout << "The original stack is not empty." << endl
		<< "The top element of the original stack: "
		<< copyStack.top() << endl;
	dummyStack = stack; //copy stack into dummyStack
	cout << "The elements of dummyStack: ";
	while (!dummyStack.isEmptyStack()) //print dummyStack
	{
		cout << dummyStack.top() << " ";
		dummyStack.pop();
	}
	cout << endl;
	return 0;

}
void testCopyConstructor(linkStack<int> otherStack)
{
	if (!otherStack.isEmptyStack())
		cout << "otherStack is not empty." << endl
		<< "The top element of otherStack: "
		<< otherStack.top() << endl;
}

[[栈的数组实现]]

春明外史
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
栈的实现（C语言）数组实现以及链表实现
05-25
栈的实现（C语言）数组实现以及链表实现源码，以及各个功能测试代码函数等 和后缀式转前缀式的用例
数据结构 栈 链表实现 c++ 模板
12-21
在链表实现的栈中，每个节点包含一个数据元素和一个指向下一个节点的指针。当执行压栈操作时，新元素被添加到链表的头部；而弹栈操作则删除链表头部的元素。由于C++的链表操作比数组更灵活，它允许在运行时动态调整...
数据结构与算法（七）--使用链表实现栈
学习不止境的博客
10-07 1037
之前我们已经学习了链表的所有操作及其时间复杂度分析，我们可以了解到。。本章我们通过链表去实现栈，当然我们也会讲到用链表实现另一个数据结构–队列。并且比较用数组实现和用链表实现他们之间的差异。
使用链表实现栈（基础）
Sorry_Jaime的博客
07-28 354
链表实现栈
链栈的基本操作（链表实现）
最新发布
2301_80224556的博客
04-27 665
int data;// 数据域// 指针域。
栈的实现之用链表实现
欢迎留言技术探讨
07-07 515
用链表实现栈 上次我们用数组实现了栈，数组结构实现栈比较容易，那么用链表该如何实现栈呢？
基于数组或链表的堆栈实现
秋枫林的专栏
08-20 2459
本文使用C语言，给出了堆栈的两种实现：基于数组和基于链表的实现方式。堆栈是一种常用的数据结构，具有“后进先出（Last In First Out）”的特性，常用来进行函数调用时候的参数传递，解决递归函数书的非递归实现，表达式中的括号匹配等问题。堆栈的常用操作如下： createStack(st)：建立一个空栈 push(st, x)：将元素x压入栈st当中，使之成为栈顶
链表ADT设计模板的简单应用——链表的ADT的实现C++版
Blackoutdragon的博客
10-17 1479
文章目录ADT分析总结LinkList(LinkList &List);分析与总结operator=(LinkList &List) 、ListDestroy()和ClearList（）ListDestroy()ListClear()分析与总结ListLength（）和ListEmpty()分析与总结InsFirst分析与总结GetElem（int pos） 、ListInsert(int pos,ElemType e)和DelFirst(ElemType &e)分析与总结Creat
栈链表_c语言/栈链表_
09-29
在C语言中，我们可以通过链表来实现栈的功能，这就是所谓的“栈链表”。在这个主题下，我们将深入探讨栈链表的概念、设计以及在C语言中的实现。 栈链表的核心是链表节点，每个节点包含一个数据元素和指向下一个节点...
Java基于链表实现栈的方法详解
08-19
Java基于链表实现栈的方法详解 在计算机科学中，栈是一种常用的数据结构，常用于实现递归算法、函数调用、表达式求值等场景。Java中有多种方式实现栈，其中使用链表实现栈是一种常见的方法。下面将详细介绍Java基于...
链表-使用Python基于链表实现数组栈.zip
03-13
因此，题目中提到的“链表-使用Python基于链表实现数组栈”就是将栈的特性与链表的高效插入和删除结合，创建一个更高效的栈数据结构。 为了实现基于链表的数组栈，我们需要定义一个Stack类，包含head（栈顶）属性和...
链表栈的实现
周杰伦
08-11 849
在Linux的环境下编辑代码 . #include&lt;iostream&gt; #include&lt;stdlib.h&gt; using namespace std; //定义节点 struct Node { //数据域： int data; //指向域 struct Node* next;//指向域 }; //栈类 class Cstack { //方法 publi...
栈：使用链表实现一个栈
EDGNB6666的博客
03-03 819
#include<iostream> using namespace std; struct Node { int data; Node* link; }; Node* top = NULL; void Push(int x) { Node* temp = new Node; temp->data = x; temp->link = top; top = temp; } void Pop() { Node* temp; if(top == NULL) re.
【数据结构】如何用单链表实现栈？
好吃的爆米花
07-20 5498
文章目录一、前言二、源码下载：持续更新中三、什么是栈？三、链表节点四、栈结构的定义五、栈空判断六、栈满判断七、入栈push(int value) 实现八、出栈pop()实现九、栈的打印（单向链表的逆序打印） 一、前言 工作之余，学习一下数据结构与算法，今天学习数据结构：“栈”。 相信各位帅气的程序员对这个栈是相当的熟悉。 但是笔者就总有一个臭毛病：一看就会，一写就拉稀。 所以今天小编就自己动手亲自用单向链表实现“栈” 二、源码下载：持续更新中 https://gitee.com/sunshineAndD
深入理解数据结构（1）—用链表实现栈
From_C的博客
10-27 409
栈是一种数据结构，链表也是一种数据结构。它们都是由基础的语法实现的。 如果一个数据结构可以用另外的数据结构来实现，那么可以有力的证明——“数据结构是一种思想”，是一种讲语法组合起来实现某种功能的手段
[C语言实现]栈和队列&链表实现
m0_73976305的博客
04-02 294
循环队列 共享栈
链表方式实现栈和队列（C语言）
weixin_73567058的博客
04-21 888
栈（Stack）是一种常见的数据结构，它是一种线性数据结构，具有后进先出（Last In First Out, LIFO）的特点。栈可以看作是一个容器，只能在容器的一端进行插入和删除操作，这一端被称为栈顶（Top），另一端被称为栈底（Bottom）。栈的基本操作有入栈（Push）、出栈（Pop）、获取栈顶元素（Top）和判断栈是否为空（Empty）。入栈操作将一个元素插入到栈顶，出栈操作将栈顶元素删除并返回，获取栈顶元素操作返回栈顶元素但不删除，判断栈是否为空操作返回一个布尔值。
数据结构-栈实现（链表）
weixin_51558481的博客
05-03 617
底层用链表实现 1.push：插入函数（采用头插法-head为栈顶） public void push(int data){//头插法插入元素 if(size == 0){//判断是否为空 head = new Node(data); } Node node = new Node(data);//存储节点数据 node.next = head;//将新节点和之前的节点连接
c++ 栈的链表实现
07-27
C++中栈的链表实现可以使用链表来模拟栈的结构。在这种实现中，我们可以使用std::list来作为底层数据结构。\[1\]栈的结构可以定义为一个类，其中包含一个std::list类型的成员变量stk来存储栈中的元素。此外，我们...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值