数据结构 —— 栈的顺序存储结构与链式存储结构 代码

最近复习数据结构，学到栈这里，说到栈是限定仅仅在表尾进行插入和删除操作的线性表，其实现同线性表一样具有顺序存储结构与链式存储结构两种实现方式，本人基于着两种方式对栈结构进行了实现，下面直接上代码：

	#pragma once
#include <memory>
namespace RL 
{
// 栈的链式存储结构代码
	template<typename SElemType>
	class StackNode
	{
	public:
		typedef std::shared_ptr<StackNode<SElemType>> StackNodePtr;
		SElemType data;
		StackNodePtr next;
	};


	template<typename SElemType>
	class LinkStack
	{
	public:
		typedef std::shared_ptr<StackNode<SElemType>> StackNodePtr;
		LinkStack()
		{
			top = nullptr;
			count = 0;
		}
		~LinkStack()
		{

		}

		int Push(const SElemType &e) 
		{
			StackNodePtr node = std::shared_ptr<StackNode<SElemType>>(new StackNode<SElemType>());
			node->data = e;
			node->next = top;
			top = node;
			count++;
			return 0;
		}

		int GetPop(SElemType &e)
		{
			if (top)
			{
				e = top->data;
			/*	top = top->next;
				count--;*/
				return 0;
			}
			return 1;
		}

		bool Clear()
		{
			while (count)
			{
				Pop();
			}
		}
		SElemType Pop()
		{
			SElemType e;
			if (top)
			{
				e = top->data;
				top = top->next;
				count--;
			}
			return e;
		}

		bool isEmpty() 
		{
			return count?false:true;
		}
		int Length()
		{
			return count;
		}

	private:
		StackNodePtr top;
		int count;
	};


// 栈的顺序存储结构代码
	template<typename SElemType>
	class SqStack
	{
	public:
		SqStack() 
			:m_capacity(10)
			, m_length(0)
		{
			m_data_array_ptr = new SElemType[m_capacity];
		}
		SqStack(int _capacity)
			:m_capacity(_capacity)
			, m_length(0)
		{
			m_data_array_ptr = new SElemType[m_capacity];
		}

		~SqStack() 
		{
			if (m_data_array_ptr)
			{
				delete[]m_data_array_ptr;
			}
		}
		void Push(const SElemType &e)
		{
			if (m_length >= m_capacity)
			{
				m_capacity *= 2;
				SElemType * _data_array_ptr = new SElemType[m_capacity];
				for (int i = 0; i < m_length; i++)
				{
					_data_array_ptr[i] = m_data_array_ptr[i];
				}
				delete[]m_data_array_ptr;
				m_data_array_ptr = _data_array_ptr;
			}
			m_data_array_ptr[m_length++] = e;
		}

		SElemType Pop() 
		{
			if (m_length)
			{
				return m_data_array_ptr[--m_length];
			}
			return SElemType();
		}

		int ReSetCapacity(int _capacity)
		{
			if (_capacity <= 0)
			{
				return 1;
			}
			if (m_data_array_ptr)
			{
				delete[]m_data_array_ptr;
			}
			m_capacity = _capacity;
			m_data_array_ptr = new SElemType[m_capacity];
			return 0;
		}

		bool isEmpty()
		{
			return m_length ? false : true;
		}
		int Length()
		{
			return m_length;
		}
		int Capacity() 
		{
			return m_capacity;
		}

		bool Clear()
		{
			m_length = 0;
		}
	private:
		int m_capacity;
		int m_length;
		SElemType * m_data_array_ptr;
	};
}