数据结构 栈(动态数组)

 

由静态数组实现的栈的的缺陷是明显的，他很容易造成空间的浪费或则空间不足；倘若我们在运行程序的时候是可以知道栈的大小的话，那么动态数组实现的栈无疑使最好的选择；当然，在动态数组中的栈，其构造函数要做的事远比静态的要多，此外还需要一些其他的函数成员：

（1）构造函数：处理动态数据成员的内存分配，并初始化所有的数据成员；

（2）析构函数：释放一个对象中所有的动态分配内存；

（3）复制构造函数：创建对象的复制；

（4）赋值运算符：将一个对象赋予另一个对象；

其他和静态实现的栈基本相同；静态实现的栈参考：http://blog.csdn.net/u013946585/article/details/37612547

1.构造函数：在静态数组的栈中因为数组已经存在，构造函数只需要初始化栈空即可，但在动态数组中则需要先创建一个合法的数组，然后再初始化栈空；

算法描述如下：

（1）检查给定的栈容量是否合法，若非法，则跳转至（6），否则执行（2）
（2）设置capacity为number，执行（3）
（3）分配一个容量为number的数组，由myArray指向其首地址
（4）检查myArray是否为空，若空，则跳转至（6），否则执行（5）
（5）设置myTop为-1；
（6）结束程序

具体代码如下：

#include <iostream>
using namespace std;

typedef int stack_element;


//动态栈的声明部分
class stack
{
	public :
		stack (int number = 128);
		stack (const stack & original);  //复制构造函数
		~stack ();
		const stack & operator = (const stack & RightStack); //赋值运算符
		bool empty () const;
		void push (stack_element item);
		void display (ostream & out) const;
		stack_element top () const;
		void pop ();
	private :
		stack_element * myArray;  //存储元素的动态数组
		int myTop; //栈顶
		int capacity;  //栈的容量
};


//动态栈的实现部分
//构造函数
stack::stack (int number)
{
	if (number < 0)
		return;
	else
	{
		capacity = number;
		myArray = new (nothrow) stack_element[number];
		if (myArray)
			myTop = -1;
		else
			cerr << "new a new myArray Error\n";
	}
}

//stack的复制构造函数的定义
stack::stack (const stack & original) : capacity (original.capacity),myTop(original.myTop)
{
	//为复制创建一个新的数组
	myArray = new (nothrow) stack_element[capacity];
	if (myArray)
		for (int i=0; i<myTop; i++)
			myArray[i] = original.myArray[i];
	else
		cerr << "Inadequate memeory to allocate stack\n";
}

//赋值运算符的定义
const stack & stack::operator = (const stack & RightStack)
{
	if (this != &RightStack)//确定不是自我赋值
	{
		if (RightStack.capacity != capacity) //检查大小是否一样
		{
			delete [] myArray;
			capacity = RightStack.capacity;
			myArray = new (nothrow) stack_element[capacity];
			if (myArray==0)
				cerr << "Inadequate memeory to allocate stack\n";
			else
			{
				myTop = RightStack.myTop;
				for (int i=0; i<myTop; i++)
					myArray[i] = RightStack.myArray[i];
			}
		}
	}
	return *this;
}

stack::~stack ()
{
	delete [] myArray;
}
bool stack::empty () const
{
	return myTop == -1;
}

void stack::display (ostream & out) const
{
	for (int i=myTop; i>=0; i--)
		out << myArray[i] << endl;	
}

void stack::push (stack_element item)
{
	if (myTop < capacity-1)
	{	myTop++;
		myArray[myTop] = item;
	}
	else
		cerr << "Push Error\n";
}

stack_element stack::top () const
{
	if (myTop != -1)
		return myArray[myTop];
	else
		cerr << "Stack is Empty\n";
}

void stack::pop ()
{
	if (myTop != -1)
		myTop--;
	else
		cerr << "Stack is Empty\n";
}

void print (stack s)
{
	s.display (cout);
}

//动态数组栈的测试部分
int main ()
{
	int cap;
	cout << "Enter stack capacity: \n";
	cin >> cap;
	stack s(cap);
	cout << "stack created. Empty ?\n" << ((s.empty () ? "yes":"no")) << endl;

	cout << "How many elements to add to the stack ?\n";
	int number;
	cin >> number;
	for (int i=0; i<number; i++)
		s.push (i);
	cout << "stack empty ?\n" <<((s.empty () ? "yes":"no")) << endl;
	
	cout << "contents of stack s (via  print ) :\n";
	print (s);
	cout << "\ncheck that stack wasn't modified by print :\n";
	s.display (cout);
	stack u,t;
	t = u = s;
	cout <<"contents of stack t and u after t = u = s :\n";
	cout << "u: \n";print (u);
	cout << "\nt: \n";print (t);
	cout << "\ntop value int t: "<< t.top () << endl;
	while (!t.empty ())
	{
		cout << "Poping t: "<<t.top() <<endl;
		t.pop ();
	}
	cout << "stack t empty ?\n" << ((t.empty () ? "yes":"no")) << endl;
	cout << "stack t top value " <<t.top () <<endl;
	return 0;
}