C++数据结构——链栈

主页有其他数据结构内容（持续更新中）

代码：

#include<iostream>
using namespace std;


template <class T>
struct Node
{
	T data;  //数据域
	Node<T>* next;  //指针域
	
	Node()
	{
		next = nullptr;
	}

	explicit Node(T item, Node<T>* ptr = nullptr)
	{
		data = item;
		next = ptr;
	}
};


template <class T>
class LinkStack
{
	int count;                     //栈的大小
	Node<T>* lstop;          //栈顶指针

public:
	LinkStack();                       //构造函数
	LinkStack(const LinkStack& item);  //拷贝构造函数
	~LinkStack();              //析构函数
	void push(const T& item);            //进栈操作
	void pop();                        //出栈操作
	bool empty()const;                    //判断栈是否为空栈
	int size();                     //获取栈的大小
	T top();                //获取栈顶元素
	LinkStack<T>& operator=(const LinkStack& item);  //赋值运算符重载
};


template <class T>
LinkStack<T>::LinkStack()  //构造函数
{
	lstop = nullptr;
	count = 0;
}


template <class T>
LinkStack<T>::LinkStack(const LinkStack& item)  //拷贝构造函数
{
	Node<T>* new_copy;
	Node<T>* original_node = item.lstop;
	if (original_node == nullptr)
	{
		lstop = nullptr;
	}
	else
	{
		lstop = new_copy = new Node<T>(original_node->data);
		while (original_node->next != nullptr)
		{
			original_node = original_node->next;
			new_copy->next = new Node<T>(original_node->data);
			new_copy = new_copy->next;
		}
	}
	count = item.count;
}


template <class T>
LinkStack<T>::~LinkStack()  //析构函数
{
	while (!empty())
	{
		pop();
	}
}


template <class T>
void LinkStack<T>::push(const T& item)  //插入元素
{
	Node<T>* temp = new Node<T>(item, lstop);
	if (temp == nullptr)    //  未能成功申请到内存(但几乎不会发生)
	{
		cout << "Overflow!" << endl;
	}
	else
	{
		lstop = temp;
	}
	temp = nullptr;
	delete temp;
	count++;
}


template <class T>
void LinkStack<T>::pop()  //弹出元素
{
	if (count == 0)
	{
		cout << "Underflow!" << endl;
	}
	else
	{
		Node<T>* temp = lstop;
		lstop = temp->next;
		temp = nullptr;
		delete temp;
		count--;
	}
}


template <class T>
bool LinkStack<T>::empty()const  //判栈空
{
	return count == 0;
}


template <class T>
int LinkStack<T>::size()  //返回栈的大小
{
	return count;
}


template <class T>
T LinkStack<T>::top()  //返回栈顶元素
{
	if (count == 0)
	{
		cout << "Overflow!" << endl;
	}
	else
	{
		return lstop->data;
	}
}


template <class T>
LinkStack<T>& LinkStack<T>::operator=(const LinkStack& item)  //重载赋值运算符
{
    Node<T>* new_copy;
    Node<T>* original_node = item.lstop;
    if (original_node == nullptr)
    {
        lstop = nullptr;
    }
    else
    {
        lstop = new_copy = new Node<T>(original_node->data);
        while (original_node != nullptr)
        {
            original_node = original_node->next;
            new_copy->next = new Node<T>(original_node->data);
            new_copy = new_copy->next;
        }
    }
    count = item.count;
    return *this;
}


int main()
{
	LinkStack<int> ls;
	for (int i = 0; i < 10; i++)
	{
		ls.push(i);
	}
	cout << "栈的长度为：" << ls.size() << endl;

	LinkStack<int> copy_1 = ls; //  测试重载之后的赋值运算符
	while (!copy_1.empty())
	{
		cout << copy_1.top() << " ";
		copy_1.pop();
	}
	cout << endl;

	LinkStack<int> copy_2 = LinkStack<int>(ls); //  测试拷贝构造函数
    while (!copy_2.empty())
    {
        cout << copy_2.top() << " ";
        copy_2.pop();
    }

	return 0;
}