C++之简单实现stack

最新推荐文章于 2024-08-11 22:17:46 发布
原创 最新推荐文章于 2024-08-11 22:17:46 发布 · 389 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文详细介绍了如何从零开始实现一个类似于STL中的stack容器，利用自定义的list作为底层数据结构，深入探讨了stack的基本操作如push、pop、top及清空等，并通过测试代码验证了其正确性和效率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

简介

stack是配接器：

一种用来修饰容器（containers）
或仿函式（functors）
或迭代器（iterators）接口的东西

stack在源码中底层是deque，由于deque还没写，刚写了list，就用list来实现stack。
环境：VS2017

list迭代器

#pragma once

#include <iostream>
using std::cout;
using std::cerr;
using std::endl;

namespace HN
{
	template<typename T> struct hn_list_node;//下边要用到，所以先声明,仅声明模板使用extern报错，原因未知
	template<class T> class hn_list;//下边要用到，所以先声明，仅声明模板使用extern报错，原因未知

	//const迭代器

	template<typename T>
	class const_iterator
	{
	public:
		friend class hn_list<T>;//设置友元以访问hn_list
		const_iterator() :current(NULL)
		{
		}

		const T& operator*() const
		{
			return current->node;
		}

		const_iterator & operator++(int)
		{
			const_iterator old = *this;
			++(*this);
			return old;
		}

		const_iterator & operator++()
		{
			current = current->next;
			return *this;
		}

		bool operator == (const const_iterator & rhs) const
		{
			return current == rhs.current ? true : false;
		}

		bool operator != (const const_iterator & rhs) const
		{
			return !(current == rhs.current);
		}

		hn_list_node<T> * operator -> ()
		{
			return current;
		}

		~const_iterator()
		{
		}

	protected:
		hn_list_node<T> * current;
		T& retrieve() const//恢复，即得到节点
		{
			return current->node;
		}
	private:

	};

	//普通迭代器，继承自cosnt迭代器

	template<typename T>
	class iterator : public const_iterator<T>
	{
	public:
		friend class hn_list<T>;//设置友元以访问hn_list
		iterator()
		{
		}

		//非const默认调用此版本
		const T& operator * ()
		{
			//cout << "调用非const版本operator *()" << endl;
			return const_iterator<T>::current->node;
		}

		//可以看到根据是否为const对象函数可以实现重载,const对象调用此版本
		const T& operator * () const
		{
			//cout << "调用const版本operator *()" << endl;
			return const_iterator<T>::operator *();
		}

		iterator& operator++()//前置自增
		{
			const_iterator<T>::current = const_iterator<T>::current->next;
			return *this;
		}

		iterator& operator++(int)//后置自增
		{
			iterator old = *this;
			++(*this);
			return old;
		}

		~iterator()
		{
		}
	};
}

list实现

#pragma once

#include "hn_iterator.h"

namespace HN
{
	//template<typename T> class const_iterator;
	//template<typename T> class iterator;

	//链表节点
	template<typename T>
	struct hn_list_node
	{
		hn_list_node<T> * pre;
		hn_list_node<T> * next;
		T node;

		hn_list_node() :pre(nullptr), next(nullptr)
		{
		}
		hn_list_node(const T & obj) :node(obj), pre(nullptr), next(nullptr)
		{
		}
	};

	//链表
	template<class T>
	class hn_list
	{
	public:
		typedef const_iterator<T> const_iterator;//简化
		typedef iterator<T> iterator;//简化
		hn_list() :head_node_ptr(new hn_list_node<T>()), tail_node_ptr(new hn_list_node<T>()), theSize(0)
		{
			cout << "进入hn_list无参构造" << endl;
			head_node_ptr->next = tail_node_ptr;
			tail_node_ptr->pre = head_node_ptr;
		}
		hn_list(int size) :head_node_ptr(new hn_list_node<T>()), tail_node_ptr(new hn_list_node<T>()), theSize(size)
		{
			cout << "进入hn_list指定大小构造" << endl;
			head_node_ptr->next = tail_node_ptr;
			tail_node_ptr->pre = head_node_ptr;
			for (int i = 0; i < theSize; i++)
			{
				hn_list_node<T> * tmp = new hn_list_node<T>();
				tail_node_ptr->pre->next = tmp;
				tmp->pre = tail_node_ptr->pre;
				tmp->next = tail_node_ptr;
				tail_node_ptr->pre = tmp;
			}
		}

		const_iterator begin() const
		{
			const_iterator it;
			it.current = head_node_ptr->next;
			return it;
		}

		const_iterator  end() const
		{
			const_iterator it;
			it.current = tail_node_ptr;
			return it;
		}

		iterator begin()
		{
			iterator it;
			it.current = head_node_ptr->next;
			return it;
		}

		//拷贝构造函数
		hn_list(const hn_list<T> & rhs) :head_node_ptr(new hn_list_node<T>()), tail_node_ptr(new hn_list_node<T>()), theSize(rhs.theSize)
		{
			cout << "进入hn_list拷贝构造" << endl;
			head_node_ptr->next = tail_node_ptr;
			tail_node_ptr->pre = head_node_ptr;
			for (const_iterator it = rhs.begin(); it != rhs.end(); it++)
			{
				push_back(*it);
			}
		}

		void push_back(const hn_list_node<T>& rhs)
		{
			hn_list_node<T> *tmp = new hn_list_node<T>(rhs);
			tail_node_ptr->pre->next = tmp;
			tmp->pre = tail_node_ptr->pre;
			tmp->next = tail_node_ptr;
			tail_node_ptr->pre = tmp;
			++theSize;
		}

		void push_front(const T& rhs)
		{
			hn_list_node<T> * tmp = new hn_list_node<T>(rhs);
			head_node_ptr->next->pre = tmp;
			tmp->next = head_node_ptr->next;
			head_node_ptr->next = tmp;
			tmp->pre = head_node_ptr;
			++theSize;
		}
		void pop_front()
		{
			if (empty())
				return;
			hn_list_node<T> * tmp = head_node_ptr->next;
			head_node_ptr->next = tmp->next;
			tmp->next->pre = head_node_ptr;
			delete tmp;
			--theSize;
		}
		void pop_back()
		{
			if (empty())
				return;
			hn_list_node<T>* tmp = tail_node_ptr->pre;
			tmp->pre->next = tail_node_ptr;
			tail_node_ptr->pre = tmp->pre;
			delete tmp;
			--theSize;
		}
		bool empty()
		{
			return theSize == 0 ? true : false;
		}
		void clear()
		{
			while (!empty())
			{
				pop_back();
			}
		}
		void resize(int num)
		{
			if (num == theSize)
			{
				return;
			}
			else if (num > theSize)
			{
				int n = num - theSize;
				for (int i = 0; i < n; i++)
				{
					push_back(T());
				}
			}
			else
			{
				int n = theSize - num;
				for (int i = 0; i < n; i++)
				{
					pop_back();
				}
			}

		}
		T& front()
		{
			return head_node_ptr->next->node;
		}
		T& back()
		{
			return tail_node_ptr->pre->node;
		}
		int size()const
		{
			return theSize;
		}

		//应再实现一个iterator版本
		void insert(const_iterator it, const T& rhs)
		{
			hn_list_node<T> * tmp = it.current;
			hn_list_node<T> * new_node = new hn_list_node<T>(rhs);
			tmp->pre->next = new_node;
			new_node->pre = tmp->pre;
			new_node->next = tmp;
			tmp->pre = new_node;
			++theSize;

		}

		//只删除第一个相等的节点
		void remove(const T& rhs)
		{
			if (empty())
				return;
			else
			{
				for (iterator it = begin(); it != end(); it++)
				{
					if (*it == rhs)
					{
						cout << "remove  " << *it << endl;
						hn_list_node<T> * tmp = it.current;
						tmp->next->pre = tmp->pre;
						tmp->pre->next = tmp->next;
						delete tmp;
						--theSize;
						return;//已经remove了，应当返回，因为迭代器已经失效了
					}
				}
			}
		}
		//此处返回hn_list<T>&，用以支持连等，即ld = lc = lb;
		//也可以返回void
		const hn_list<T>& operator = (const hn_list<T>& rhs)
		{
			cout << "进入赋值运算符" << endl;
			if (this == &rhs)
			{
				return *this;
			}
			else
			{
				this->clear();
				hn_list::const_iterator it = rhs.begin();
				for (; it != rhs.end(); it++)
				{
					push_back(*it);
				}
				return *this;
			}
		}

		//仅仅为了测试写的，便于查看各个元素
		void show()
		{
			hn_list_node<T> * tmp = head_node_ptr->next;
			while (tmp!=tail_node_ptr)
			{
				cout << tmp->node << " ";
				tmp = tmp->next;
			}
			cout << endl;
		}

		bool operator == (const hn_list<T> & rhs)
		{
			if (this == &rhs)
			{
				return true;
			}
			else if(theSize==rhs.theSize)
			{
				hn_list::const_iterator itl = begin();
 				hn_list::const_iterator itr = rhs.begin();
				while (itl!=end() && itr!=rhs.end())
				{
					if (itl.current->node != itr.current->node)
					{
						return false;
					}
					itl++;
					itr++;
				}
				return true;
			}
			else
			{
				return false;
			}
		}

		~hn_list()
		{
			cout << "进入hn_list析构" << endl;
			if (head_node_ptr != NULL)
				delete head_node_ptr;
			if (tail_node_ptr != NULL)
			{
				delete tail_node_ptr;
			}
		}

	protected:
		hn_list_node<T> * head_node_ptr;
		hn_list_node<T> * tail_node_ptr;
		int theSize;
	};


}

stack实现

#pragma once
#include <iostream>
#include "hn_list.h"
using std::cout;
using std::cerr;
using std::endl;

using namespace HN;
namespace HN
{
	//此处默认传入我自己写的list，也可以传入std::list
	template<typename T,class hn_List=hn_list<T>>
	class hn_stack
	{
	public:
		hn_stack()
		{
			cout << "进入hn_stack无参构造函数" << endl;
		}
		~hn_stack()
		{

		}

		void clear()
		{
			return list.clear();
		}

		bool empty()
		{
			return list.empty();
		}

		int size() const
		{
			return list.size();
		}

		void push(T t)
		{
			list.push_back(t);
		}

		void pop()
		{
			if (list.empty())
			{
				cerr << "栈已空！！！";
				return;
			}
			else
			{
				list.pop_back();
			}
		}

		T& top()
		{
			return list.back();
		}

		void show()
		{
			list.show();
		}

		bool operator == (const hn_stack<T, hn_List> & rhs)
		{
			return list == rhs.list;
		}

	protected:
		hn_List list;

	};


}

测试代码


#include "pch.h"
#include "hn_stack.h"
#include <stack>
using namespace std;

int main()
{
    std::cout << "Hello World!\n"; 
	hn_stack<int> sa;
	sa.push(1);
	sa.push(3);
	sa.push(5);
	cout << "sa.empty(): " << (true==sa.empty()?"true":"false") << endl;
	cout << "sa.size(): " << sa.size() << endl;
	sa.show();
	sa.pop();
	sa.pop();
	sa.pop();
	sa.pop();
	sa.show();
	sa.push(1);
	sa.push(3);
	sa.push(5);
	sa.push(1);
	sa.push(3);
	sa.push(5);
	sa.show();
	cout<<"sa.top(): "<<sa.top() << endl;
	sa.top()++;
	cout << "sa.top(): " << sa.top() << endl;
	sa.clear();
	cout << "after clear:-------------------------------------------------" << endl;
	cout << "sa.empty(): " << (true == sa.empty() ? "true" : "false") << endl;
	cout << "sa.size(): " << sa.size() << endl;
	sa.push(1);
	sa.push(3);
	sa.push(5);
	sa.push(1);
	sa.push(3);
	sa.push(5);
	cout << "sa.size(): " << sa.size() << endl;
	sa.show();
	hn_stack<int> sb;
	sb.push(1);
	sb.push(3);
	sb.push(5);
	sb.push(1);
	sb.push(3);
	sb.push(5);
	cout << "sb.size(): " << sb.size() << endl;
	sb.show();
	cout << "sa==sb? : " << (sa == sb?"true":"false") << endl;
	cout << "TEST END!!!" << endl;
}

测试结果

在这里插入图片描述

总结

list的实现略有修改，所以此处再次贴出。
stack实现了基本功能，符合预期。

C++实现堆栈stack(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-11 792
C++实现堆栈stack实现堆栈stack算法的完整源码（定义，实现，main函数测试） 实现堆栈stack算法的完整源码（定义，实现，main函数测试） #ifndef DATA_STRUCTURES_STACK_H_ #define DATA_STRUCTURES_STACK_H_ #include <cassert> #include <iostream> /** Definition of the node as a linked-list * \tparam Type
C/C++ array实现stack算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-27 2179
array实现stack算法的原理是使用一个数组来存储栈中的元素，并使用一个指针来指示栈顶位置。通过修改指针的值，可以实现元素的插入和删除操作。array实现stack算法的原理是使用一个数组来存储栈中的元素，并使用一个指针来指示栈顶位置。通过修改指针的值，可以实现元素的插入和删除操作。array实现stack算法的原理是使用一个数组来存储栈中的元素，并使用一个指针来指示栈顶位置。array实现stack算法的原理是使用一个数组来存储栈中的元素，并使用一个指针来指示栈顶位置。
C和C++实现Stack
令狐葱的技术博客
09-09 3624
/************************************************************************//*  使用c++实现Stack                                                    *//*****************************************************
c++中 stack的简单实现
weixin_41525190的博客
06-18 1022
#include&lt;iostream&gt; #define Maxsize 100//栈最大长度 using namespace std; template&lt;class numtype&gt;//模板类 class stack { public: int size()//元素个数 { return (top+1); } void push(int data);//出栈 ...
C++的Stack实现
runyon的博客
10-10 516
初始版本，未引入异常，未将声明与实现分开 #include #include class Stack { public:     Stack(int capacity_)         : elements(NULL)         , top(0)         , capacity(capacity_)     {         elements = new int[capaci
c++栈（Stack）的实现
qq_53745697的博客
11-20 675
栈的链式存储和顺序存储 #include<stdio.h> #include<stdlib.h> #define MaxSize 20//存储的最大个数 typedef int E; typedef struct { E A[MaxSize]; int top; }arrayStack,*pArrayStack; pArrayStack craete(){ //创建栈 pArrayStack p = (pArr..
C++ STL Queue,Stack底层实现分析
qq_51845557的博客
10-17 2406
C++容器适配器(Adapter) stack与queue是非常常用的STL容器.队列与栈也是比较基础的数据结构类型.今天我们来实现一个stack与一个queue. 基本结构 stack也就是栈,遵循的是先进后出原则.queue也就是队列,遵循的是先进先出的原则. 作为基本数据结构的队列与栈没有什么难点. 此外,stack与queue不能遍历,不能随机访问,不能查询中间结点,不能插入中间结点,只能做与其性质对应的两端结点的操作. STL...
C++：容器适配器stack详解
最新发布
qq_43441284的博客
08-11 557
在两个栈之间交换元素，最直接的方法是使用swap函数（如果语言支持）或者手动将元素从一个栈转移到另一个栈中，然后反向操作以完成交换。
C++栈(stack)的模板类实现代码
08-30
在C++标准库中，`<stack>`提供了栈的模板类实现，但这里我们将讨论如何使用C++自定义模板类来实现一个简单的栈。 首先，栈的基本操作包括： 1. `push`：将元素添加到栈顶。 2. `pop`：移除栈顶元素并返回其值。 3. ...
C/C++ stack实现深度优先搜索DFS算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
06-17 7058
深度优先搜索（Depth First Search，DFS）是一种图遍历算法，它从一个节点开始，通过访问其相邻节点的方式，依次深入到图中的更深层次。Stack（栈）是一种先进后出（Last In First Out，LIFO）的数据结构，它非常适合实现DFS算法。首先，我们来解释一下Stack实现DFS算法的原理。DFS算法的核心思想是从起始节点开始，将其标记为已访问，并将其相邻节点入栈。然后取出栈顶节点，将其标记为已访问，并将其未访问的相邻节点入栈，直到栈为空。这样就完成了一次深度优先搜索。
堆栈类Stack的C++实现
04-18
堆栈类stack的C++实现，包含了栈类的常规操作和方法，对初学者很有用哦。。
C++ 实现堆栈stack类模板
04-07
实现堆栈stack类模板，类模板的模型为：堆栈按数组索引减小的方向增长.
堆栈类的实现（C++源代码）
10-11
本代码简单的实现了C++堆栈类的实现方式，仅供参考学习
C++实现stack【栈】
weixin_30652897的博客
04-03 92
要求： //****file: stack.h/*对stack进行初始化检查stack为空，或已满将整数压入到stack中从stack里弹出整数 不移除任何袁术，讲过stack的内容输出到标准输出Stack类的私有成员如下：一个用于打印错误信息的私有哦成员函数三个私有数据成员构成了stack类的private实现，此实现为类接口提供支持。 */ 类的实现 1 #include &...
堆栈（Stack）实现（C++）
weixin_43361652的博客
01-28 7399
一. 堆栈（Stack） 堆栈（Stack） 是一种可以存取的数据结构，其主要特征是先进后出（Last-in-first-out, LIFO） 栈顶（Top） 是最后入栈的数据 堆栈可分为静态堆栈（Static Stack）和动态堆栈（Dynamic Stack）两类： Static Stack： 栈的大小固定，可以用数组实现； Dynamic Stack： 栈的大小随需要改变，可以用链表实现 二. 基本操作（Basic Operation） 入栈（Push）：Equivalent to an in
【C++项目实战】构建栈Stack
积流成河
06-21 445
1 知识点 Rudimentary applications by pointer: stack, queue, linked list, rooted tree （指针的基础应用：栈，队列，有序列表，有序根树） systhesize objects and points by array （用数组来构建对象和指针） stack: last in, first out, LIFO （栈是后进先出） queue: first in, first out, FIFO （队列是先进先出） operations:
C++ 手动实现栈(stack) （课后作业版）
a1367666195的博客
11-24 1120
栈，一种遵循先进先出原则的数据结构，可以用顺序表实现，也可以用链表进行实现。 这里我使用数组实现方法，包含了进栈，出栈，访问栈顶等功能，以及一些辅助功能。
C++ 写一个栈stack
qq_45122293的博客
09-08 461
#include<iostream> using namespace std; class StackInt { public: StackInt(); /*{ size = 0; for (int& i : element) { i = 0; } }*/ int getSize() { return size; } int top()...
C++ 栈（stack）实现（附源码）
input_me的博客
06-26 1407
周知众所，栈（stack）是计算机技术中不可或缺的一部分，在函数调用（尤其是递归）等方面发挥了不可或缺的作用。栈，是一种后入先出的数据结构，先进去的反而后出来。为了更好地了解栈的结构和原理，用单链表来简单实现栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值