数据结构复习（六）模板类封装实现栈

曾几何时`

已于 2023-02-19 14:10:10 修改

阅读量425

点赞数

分类专栏：数据结构文章标签：数据结构 java 开发语言

于 2023-02-15 17:31:22 首次发布

本文链接：https://blog.csdn.net/weixin_66151870/article/details/129047321

版权

数据结构专栏收录该内容

14 篇文章 0 订阅

订阅专栏

文章介绍了栈这种数据结构的基本概念和特点，包括后进先出的LIFO原则，以及压栈和出栈的操作。栈的实现主要用数组，文中提供了栈的初始化、销毁、扩容检查、入栈、出栈等关键函数的代码实现，并通过一个测试函数展示了栈的操作和元素打印。

摘要由CSDN通过智能技术生成

1.栈
1.1栈的概念及结构
        栈：一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守后进先出LIFO（Last In First Out）的原则。
        压栈：栈的插入操作叫做进栈/压栈/入栈，入数据在栈顶。
        出栈：栈的删除操作叫做出栈。出数据也在栈顶。

1.2栈的实现
栈的实现一般可以使用数组或者链表实现，相对而言数组的结构实现更优一些。因为数组在尾上插入数据的代价比较小。

栈的初始化与销毁

#include<iostream>
#define SIZE 7
template <class T>
class stack
{
public:
   stack()
       : _top(0)
       , _capacity(SIZE)
   {
       T* temp = new T[SIZE];        // 创建数组
       _array = temp;        // 使用_array来进行接收
       memset(_array, 0, sizeof(T) * SIZE);        // 初始化元素为0
   }
   ~stack()
   {
       delete _array;
       _top = 0;
       _capacity = 0;
       _array = nullptr;
   }

栈的扩容检测

   void CheckCap()
   {
       if (_top == _capacity)
       {
           int newCap = _capacity * 2;        // 确定新容量
           T* temp = new T[newCap];        // 创建新空间
           memcpy(temp, _array, sizeof(T) * _top);        // 拷贝旧空间
           delete _array;
           _array = temp;                 // 使用新空间
           _capacity = newCap;
       }
       return;
   }

栈的入栈出栈

   void Push(const T& data = T())
   {
       CheckCap();
       _array[_top] = data;
       _top++;
   }
   void Pop()
   {
       if (_top == 0)
       {
           std::cout << "栈为空无法，出栈" << std::endl;
           return;
       }
       _top--;
       return;
   }

其余函数

   bool empty()const
   {
       if (_top == 0)
           return true;
       else
           return false;
   }
   int Size()const
   {
       return _top;
   }
   T& Top()const
   {
       return _array[_top - 1];
   }
   void Print()
   {
       if (_top == 0)
       {
           std::cout << "栈中没有元素，无法打印" << std::endl;
           return;
       }
       for (int i = 0; i < _top; i++)
       {
           std::cout << _array[i] << " ";
       }
       std::cout << std::endl;
   }
private:
   T* _array;
   int _top;
   int _capacity;
};

测试

void Test()
{
   stack<int> s;
   s.Push(1);
   s.Push(2);
   s.Push(3);
   s.Push(4);
   s.Push(5);
   s.Print();
   s.Push(6);
   s.Push(7);
   s.Push(8);
   s.Print();
   s.Pop();
   s.Pop();
   s.Pop();
   s.Print();
   s.Pop();
   s.Pop();
   s.Pop();
   std::cout <<"栈中元素个数为->"<< s.Size() << std::endl;
   s.Print();
   s.Pop();
   s.Pop();
   s.Pop();
   s.Pop();
   s.Pop();
   s.Pop();
   s.Print();
   if (s.empty())
       std::cout << "栈为空" << std::endl;
   else
       std::cout << "栈不为空" << std::endl;
}

源码：



#include<iostream>
#define SIZE 7
template <class T>
class stack
{
public:
	stack()
		: _top(0)
		, _capacity(SIZE)
	{
		T* temp = new T[SIZE];
		_array = temp;
		memset(_array, 0, sizeof(T) * SIZE);
	}
	~stack()
	{
		delete _array;
		_top = 0;
		_capacity = 0;
		_array = nullptr;
	}
	void CheckCap()
	{
		if (_top == _capacity)
		{
			int newCap = _capacity * 2;
			T* temp = new T[newCap];
			memcpy(temp, _array, sizeof(T) * _top);
			delete _array;
			_array = temp;
			_capacity = newCap;
		}
		return;
	}
	void Push(const T& data = T())
	{
		CheckCap();
		_array[_top] = data;
		_top++;
	}
	void Pop()
	{
		if (_top == 0)
		{
			std::cout << "栈为空无法，出栈" << std::endl;
			return;
		}
		_top--;
		return;
	}
	bool empty()const
	{
		if (_top == 0)
			return true;
		else
			return false;
	}
	int Size()const
	{
		return _top;
	}
	T& Top()const
	{
		return _array[_top - 1];
	}
	void Print()
	{
		if (_top == 0)
		{
			std::cout << "栈中没有元素，无法打印" << std::endl;
			return;
		}
		for (int i = 0; i < _top; i++)
		{
			std::cout << _array[i] << " ";
		}
		std::cout << std::endl;
	}
private:
	T* _array;
	int _top;
	int _capacity;
};


void Test()
{
	stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	s.Print();
	s.Push(6);
	s.Push(7);
	s.Push(8);
	s.Print();
	s.Pop();
	s.Pop();
	s.Pop();
	s.Print();
	s.Pop();
	s.Pop();
	s.Pop();
	std::cout <<"栈中元素个数为->"<< s.Size() << std::endl;
	s.Print();
	s.Pop();
	s.Pop();
	s.Pop();
	s.Pop();
	s.Pop();
	s.Pop();
	s.Print();
	if (s.empty())
		std::cout << "栈为空" << std::endl;
	else
		std::cout << "栈不为空" << std::endl;
}