【栈的抽象类定义】【栈判空/进栈/出栈/访问栈顶元素】【顺序栈的抽象类实现】【顺序栈各种操作的性能分析】【链接栈的抽象类实现】

目录

【栈的定义】

【栈的抽象类定义】

【顺序栈】

【顺序栈的定义】

【顺序栈的抽象类定义】

【各种函数的实现】

【顺序栈性能分析】

【链接栈的抽象类定义】

【链接栈的具体函数实现】

---

【栈的定义】

        栈是一种运算受限的线性表，在这种线性表上进行插入和删除运算限定在某一处进行。允许进行插入和删除操作的一端被称为栈顶，另一端称为栈底，这是一种后进先出的结构（Last In First Out，LIFO）或者先进后出（First In Last Out，FILO）。

【栈的抽象类定义】

template<class elemType>
class stack
{
public://还是将创建一个空的栈的函数利用具体实现类的构造函数来实现
	virtual bool isEmpty()const = 0;//判断栈是否为空
	virtual void push(const elemType& x) = 0;//将x压入栈顶
	virtual elemType pop() = 0;//将栈顶元素弹出，删除栈顶元素，并返回当前栈顶元素值
	virtual elemType top()const = 0;//访问栈顶元素
	virtual ~stack(){}//纯虚析构函数，防止内存泄漏
};

【顺序栈】

【顺序栈的定义】

        ☆将栈中的节点存放在一段连续的存储空间（数组）；

        ☆下标为0的一端为栈底；

        ☆进栈和出栈总是在栈顶进行，不会引起像顺序表一样大规模的元素移动；

        ☆顺序栈的存储需要三个变量：（1）elem——>数组起始地址的一个指针；

                                                          （2）maxSize——>数组的大小；

                                                          （3）top_p——>栈顶的位置指针。

【顺序栈的抽象类定义】

template<class elemType>
class seqStack :public stack<elemType>
{
private:
	elemType elem;//数组elem
	int top_p;//栈顶元素的位置
	int maxSize;//栈的大小
	void doublespace();//扩大数组空间
public:
	seqStack(int initSize = 10);//构造一个空的栈，把创建栈利用构造函数来实现，有一个初始数组大小的参数
	~seqStack() { delete[]elem; }//析构函数
	bool isEmpty()const { return top_p == -1; }//栈判空，当栈中一个元素也没有的时候，规定top_p=-1
	void push(const elemType& x);//进栈
	elemType pop() { return elem[top_p--]; }//把栈顶元素删掉，并返回栈顶元素值
	elemType top()const { return elem[top_p]; }//读栈顶元素
};

【各种函数的实现】

//doubleSpace函数
template<class elemType>
void seqStack<elemType>::doublespace()
{
	elemType* tmp = elem;//把原来空间的起始地址保存起来
	maxSize *= 2;//把最大长度扩大为原来的2倍
	elem = new elemType[maxSize];//再重新申请一个新的动态空间
	for (int i = 0; i < currentLength; i++)
		elem[i] = tmp[i];//把原来数组中内容拷贝过来
	delete[]tmp;//清除原来申请的空间
}

//构造函数
template<class elemType>
seqStack<elemType>::seqStack(int initSize)
{
	elem = new elemType[initSize];
	maxSize = initSize;
	top_p = -1;//把top_p的初值赋为-1
}

//进栈
template<class elemType>
void seqStack<elemType>::push(const elemType& x)
{
	if (top_p == maxSize - 1)//判断数组里面是否还有剩余空间
		doublespace();
	elem[++top_p] = x;
}

 【顺序栈性能分析】

（1）除了进栈操作之外，所有运算实现的时间复杂度都是O（1）；

（2）进栈操作最好的时间复杂度为O（1）——数组中还有剩余空间；

                        最坏时间复杂度为O（n）——数组里面没有剩余空间，需要调用doublespace（）扩大空间；

（3）均摊分析法：

        进栈操作的均摊复杂度为：O（2）——>O（1）

简单解释一下：

        假设数组的大小为 n ，那么如果进栈操作的时间复杂度为O（n）时，说明数组已经存满了，那么也就是说，前面已经进行了 n 次的进栈操作，时间复杂度都为O（1），那么在第 n+1 次进栈的时候，需要调用doublespace（），为O（n）；

        那么，我们将第 n+1 次的操作均摊到前面的 n 次进栈操作中，那么每一次进栈多了一个拷贝的操作，即均摊时间复杂度也为O（2）——>O（1）。

【链接栈的抽象类定义】

        链接栈只在单链表的一端进行操作，时间复杂度都为O（1）。

template<class elemType>
class LinkStack :public stack<elemType>
{
private:
	struct node
	{
		elemType data;
		node* next;
		node(const elemType& x, node* N = NULL)
		{
			data = x;
			next = N;
		}
		node():next(NULL){}
		~node(){}
	};
	node* top_p;
public:
	LinkStack() { top_p = NULL; }
	~LinkStack();
	bool isEmpty()const { return top_p = NULL; }
	const push(const elemType& x) { top_p = new node(x, top_p); }
	elemType pop();
	elemType top()const { return top_p->data; }
};

 【链接栈的具体函数实现】

template<class elemType>
LinkStack<elemType>::~LinkStack()
{
	node* tmp;
	while (top_p != NULL)
	{
		tmp = top_p;
		top_p = top_p->next;
		delete tmp;
	}
}

template<class elemType>
elemType LinkStack<elemType>::pop()
{
	node* tmp = top_p;
	elemType x = tmp->data;
	top_p = top_p->data;
	delete tmp;
	return x;
}