数据结构基础(6) --顺序栈的设计与实现

栈是一种只允许在一端进行插入或删除操作的线性表.其特点为:先进后出(FILO)/后进先出(LIFO);

栈 VS. 队列

栈和队列都是动态集合, 但在栈中, 可以去掉的是最近插入的那一个,:栈实现了一种后进先出(last-in, first-out)的策略;类似的, 在队列中, 可以去掉的元素总是在集合中存在时间最长的那一个:队列实现了先进先出(first-in, first-out)的策略[下一篇我们着重复习队列].

栈的示意图:



[cpp] view
plain copy







//顺序栈的实现与解析

template <typename Type>

class MyStack

{

template <typename T>

friend ostream &operator<<(std::ostream &os, const MyStack<T> &stack);

public:

MyStack(int stackCapacity = 16);

~MyStack();

bool isEmpty() const;

void push(const Type &item);

void pop() throw (std::range_error);

const Type &top() const throw(std::range_error);

private:

Type *m_stack;

int m_top;

int m_capacity;

};

[cpp] view
plain copy







template <typename Type>

MyStack<Type>::MyStack(int stackCapacity):m_capacity(stackCapacity)

{

if (m_capacity < 1)

throw std::range_error("new size must >= 1");

//申请内存并构造对象

m_stack = new Type[m_capacity];

if (m_stack == NULL)

throw std::bad_alloc();

m_top = -1;

}

[cpp] view
plain copy







template <typename Type>

MyStack<Type>::~MyStack()

{

//析构对象并释放内存

delete []m_stack;

m_stack = NULL;

m_top = -1; //将top指针指向无效

m_capacity = 0;

}

[cpp] view
plain copy







//全局函数:数组放大/缩小

template <typename Type>

static void changeSize1D(Type *&array, int oldSize, int newSize)

throw (std::range_error, std::bad_alloc)

{

if (newSize < 0)

throw std::range_error("new size must >= 0");

Type *tmp = new Type[newSize];

if (tmp == NULL)

throw std::bad_alloc();

int minSize = std::min(oldSize, newSize);

std::copy(array, array+minSize, tmp);

delete []array; //将原数组释放掉

array = tmp; //将原指针指向新申请的数组

}

template <typename Type>

void MyStack<Type>::push(const Type &item)

{

//数组最大容量为m_capacity, 因此数组的最大下标为m_capacity-1

if (m_top >= m_capacity-1)

{

changeSize1D(m_stack, m_capacity, m_capacity * 2); //一次扩容2倍

m_capacity *= 2;

}

//将元素插入栈顶

m_stack[++ m_top] = item;

}

[cpp] view
plain copy







//栈是否为空

template <typename Type>

inline bool MyStack<Type>::isEmpty() const

{

return -1 == m_top;

}

[cpp] view
plain copy







template <typename Type>

inline const Type &MyStack<Type>::top() const

throw (std::range_error)

{

if (isEmpty())

throw std::range_error("stack is empty");

return m_stack[m_top]; //返回栈顶元素

}

[cpp] view
plain copy







template <typename Type>

inline void MyStack<Type>::pop()

throw (std::range_error)

{

if (isEmpty())

throw std::range_error("stack is empty");

//注意:如果该栈保存的对象类型的元素, 则需要显示调用其析构函数,

//同时还需要将栈顶指针下移

m_stack[m_top --].~Type();

}

[cpp] view
plain copy







//输出栈的所有内容,以便测试

template <typename Type>

ostream &operator<<(ostream &os, const MyStack<Type> &stack)

{

os << stack.m_stack[0];

for (int i = 1; i <= stack.m_top; ++i)

os << ' ' << stack.m_stack[i];

return os;

}

附-测试代码

[cpp] view
plain copy







int main()

{

MyStack<int> iStack;

iStack.push(10);

iStack.push(22);

iStack.push(15);

cout << iStack << endl;

try

{

cout << "Top = " << iStack.top() << endl;

iStack.pop();

cout << "Top = " << iStack.top() << endl;

iStack.pop();

cout << "Top = " << iStack.top() << endl;

iStack.pop();

cout << "Top = " << iStack.top() << endl;

}

catch (const std::exception &e)

{

cout << e.what() << endl;

}

}