数据结构——顺序栈

1.介绍

栈是一种比较简单的数据结构，假如说有一堆文件，我们都会习惯性的从上到下开始翻找，而不是从中间东抽一张，西找一张。

栈也是如此，它只能操作栈顶元素，只能查看栈顶元素，出栈，压栈（就是把一个元素放在栈顶）。

2.操作

我们为了便于操作栈顶元素，设置了一个栈顶的指针top，top其实为栈顶元素的下标。

我们只介绍动态存储的顺序栈，静态存储有很大局限，比如说万一想压栈内存不够怎么办，我们不得不重搞一个更大的栈，然后重新压栈。

如果一开始给一个很大的内存，万一用的时候用不了这么多，又会浪费内存。因此，这里只介绍动态存储顺序栈。

为了让压栈函数保持一致，top初始设置为-1。

（1）创建

template<typename T>
Stack<T>::Stack()
{
	top = -1;//设为-1是为了让push函数更简单
	data = new T[10];//初始设置为10
	maxSize = 10;
}

（2）判断是否为空栈、满栈。

//时间复杂度O（1）
template<typename T>
bool Stack<T>::isEmpty()
{
	if (top == -1)
		return true;
	return false;
}
//时间复杂度O（1）
template<typename T>
bool Stack<T>::isFull()
{
	if (top == maxSize - 1)
		return true;
	return false;
}

（3）压栈

//时间复杂度O（1）
template<typename T>
bool Stack<T>::push(const T& val)
{
	if (isFull())
		return false;
	data[++top] = val;//注意这里是先加后用
	return true;
}

（4）退栈

退栈只需要让栈顶指针减一。

template<typename T>
bool Stack<T>::pop()
{
	if (isEmpty())
		return false;
	top--;
	return true;
}

（5）查看栈顶元素

我们为了限制栈顶元素改动，将函数的返回值设为了const。

因为，我觉的将一个函数的返回值设为引用很奇怪，返回普通的T又会涉及到拷贝函数，因此不如就返回const T&。

//时间复杂度O（1）
template<typename T>
const T& Stack<T>::getTop()
{
	if (isEmpty())
		throw("error");
	return data[top];
}

总代码如下：

#pragma once
template<typename T>
class Stack
{
	T* data;//动态栈
	int top;//指向栈顶
	int maxSize;//栈的最大内存
	
public:
	Stack();
	~Stack();
	bool isEmpty();
	bool isFull();
	bool pop();
	const T& getTop();
	bool push(const T& val);
	bool resize();//扩容
};
template<typename T>
bool Stack<T>::resize()
{
	T* p = data;
	maxSize *= 2;
	data = new T[maxSize];
	for (int i = 0; i < maxSize / 2; i++)
		data[i] = p[i];
	delete[]p;
}
template<typename T>
Stack<T>::Stack()
{
	top = -1;//设为-1是为了让push函数更简单
	data = new T[10];//初始设置为10
	maxSize = 10;
}
template<typename T>
Stack<T>::~Stack()
{
	delete[]data;
}
//时间复杂度O（1）
template<typename T>
bool Stack<T>::isEmpty()
{
	if (top == -1)
		return true;
	return false;
}
//时间复杂度O（1）
template<typename T>
bool Stack<T>::isFull()
{
	if (top == maxSize - 1)
		return true;
	return false;
}
//时间复杂度O（1）
template<typename T>
bool Stack<T>::pop()
{
	if (isEmpty())
		return false;
	top--;
	return true;
}
//时间复杂度O（1）
template<typename T>
const T& Stack<T>::getTop()
{
	if (isEmpty())
		throw("error");
	return data[top];
}
//时间复杂度O（1）
template<typename T>
bool Stack<T>::push(const T& val)
{
	if (isFull())
		return false;
	data[++top] = val;
	return true;
}