-
何为栈？
堆栈式一种特殊的线性表，特殊之处在于两点：
a. 它是一种遵循“先进后出”的规则；
b. 只允许在固定的一端进行数据的插入和删除，称为栈顶，固定不变的一端称为栈底。
标识栈顶当前位置的变量称为栈顶指示器或栈顶指针，堆栈的插入称为进栈或入栈，堆栈的删除通常称为出栈或退栈
-
堆栈的入栈过程
-
堆栈的出栈过程
-
堆栈的操作集合
a. 入栈
b. 出栈
c. 判空
d. 求栈大小
e. 获取栈顶值 -
堆栈的实现
堆栈是一种线性结构，通常可以使用数组或链表来作为底层的数据结构。
（1）基于数组的实现
//基于数组的栈实现
# ifndef ARRAY_STACK_HPP
# define ARRAY_STACK_HPP
template<typename T>
class ArrayStack
{
public:
ArrayStack(int s = 10); //默认的栈容量为10
~ArrayStack();
public:
T top(); //获取栈顶元素
void push(T t); //压栈操作
T pop(); //弹栈操作
bool isEmpty(); //判空操作
int size(); //求栈的大小
private:
int count; //栈的元素数量
int capacity; //栈的容量
T * array; //底层为数组
};
/*构造函数*/
template <typename T>
ArrayStack<T>::ArrayStack(int s = 10)
:count(0), capacity(s), array(nullptr)
{
array = new T[capacity];
};
/*析构函数*/
template<typename T>
ArrayStack<T>::~ArrayStack()
{
if (array)
{
delete[]array;
array = nullptr;
}
};
/*栈的判空操作*/
template <typename T>
bool ArrayStack<T>::isEmpty()
{
return count == 0; //栈元素为0时为栈空
};
/*返回栈的大小*/
template <typename T>
int ArrayStack<T>::size()
{
return count;
};
/*插入元素*/
template <typename T>
void ArrayStack<T>::push(T t)
{
if (count != capacity) //先判断是否栈满
{
array[count++] = t;
}
};
/*弹栈*/
template <typename T>
T ArrayStack<T>::pop()
{
if (count != 0) //先判断是否是空栈
{
return array[--count];
}
};
/*获取栈顶元素*/
template <typename T>
T ArrayStack<T>::top()
{
if (count != 0)
{
return array[count - 1];
}
};
# endif
（2）基于链表的实现
//基于C++template实现的单链表类
# ifndef SINGLE_LIST_HXX
# define SINGLE_LIST_HXX
//节点结构
template <typename T>
class Node
{
public :
T _value;
Node* _next;
public:
Node() = default;
Node(T value, Node * next)
: _value(value), _next(next){}
};
//单链表
template <typename T>
class SingleLink
{
public:
typedef Node<T>* pointer;
SingleLink();
~SingleLink();
int size(); //获取长度
bool isEmpty(); //判空
Node<T>* insert(int index, T t); //在指定位置进行插入
Node<T>* insert_head(T t); //在链表头进行插入
Node<T>* insert_last(T t); //在链表尾进行插入
Node<T>* del(int index); //在指定位置进行删除
Node<T>* delete_head(); //删除链表头
Node<T>* delete_last(); //删除链表尾
T get(int index); //获取指定位置的元素
T get_head(); //获取链表头元素
T get_last(); //获取链表尾元素
Node<T>* getHead(); //获取链表头节点
private :
int count;
Node<T> * phead;
private :
Node<T> * getNode(int index); //获取指定位置的节点
};
//默认构造函数
template <typename T>
SingleLink<T>::SingleLink()
:count(0), phead(nullptr)
{
//创建头节点
phead = new Node<T>();
phead->_next = nullptr;
};
/*
返回指定索引的前一个位置节点，若链表为空，则返回头节点
*/
template <typename T>
Node<T>* SingleLink<T>::getNode(int index)
{
if (index > count||index < 0 )
return nullptr;
int temp = 0;
Node<T>* preNode = phead;
while (temp < index)
{
temp++;
preNode = preNode->_next;
}
return preNode;
}
/*
析构函数
*/
template <typename T>
SingleLink<T>::~SingleLink()
{
Node<T>* pNode = phead->_next;
while (nullptr != pNode)
{
Node<T>* temp = pNode;
pNode = pNode->_next;
delete temp;
}
//进行销毁
};
//返回链表的大小
template <typename T>
int SingleLink<T>::size()
{
return count;
};
//链表判空
template <typename T>
bool SingleLink<T>::isEmpty()
{
return count==0;
};
template<typename T>
Node<T>* SingleLink<T>::getHead()
{
return phead->_next;
}
/*
在指定位置插入新节点
*/
template <typename T>
Node<T>* SingleLink<T>::insert(int index, T t)
{
Node<T> * preNode = getNode(index);
if (preNode)
{
Node<T> *newNode = new Node<T>(t,preNode->_next); //构建新节点，构建时指明节点的next节点
preNode->_next = newNode;
count++;
return newNode;
}
return nullptr;
};
/*
从头部插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_head(T t)
{
return insert(0, t);
};
/*
从尾部进行插入
*/
template <typename T>
Node<T>* SingleLink<T>::insert_last(T t)
{
return insert(count, t);
};
/*
删除链表指定位置元素
*/
template <typename T>
Node<T>* SingleLink<T>::del(int index)
{
if (isEmpty())
return nullptr;
Node<T>* ptrNode = getNode(index);
Node<T>* delNode = ptrNode->_next;
ptrNode->_next = delNode->_next;
count--;
delete delNode;
return ptrNode->_next;
};
/*
删除头节点
*/
template<typename T>
Node<T>* SingleLink<T>::delete_head()
{
return del(0);
};
/*
删除尾节点
*/
template<typename T>
Node<T>*SingleLink<T>::delete_last()
{
return del(count);
};
# endif
