一个数组实现两个栈

题目：
创新互联建站是一家网站建设、网站设计，提供网页设计，网站设计，网站制作，建网站，定制设计，网站开发公司，从2013年创立是互联行业建设者，服务者。以提升客户品牌价值为核心业务，全程参与项目的网站策划设计制作，前端开发，后台程序制作以及后期项目运营并提出专业建议和思路。
一个数组A[1..n]来实现两个栈，使得两个栈中的元素总和不到n时，两个都不会发生上溯。
思路（1）：
创建一个数组，分别从两边开始，依次往中间走。
一个数组实现两个栈
思路（2）：
创建一个数组，一个走奇数位，一个走偶数位。
一个数组实现两个栈
//奇偶方式
#define  _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
template
class TwoStack
{
public:
TwoStack(int size)
:_top1(-1), _top2(-1), _len(size)
{
_arr = new T[size];
}
~TwoStack()
{
if (_arr)
{
delete[] _arr;
}
}
void Push(int index, int data);
T Pop(int index);
bool IsEmpty(int index);
void Disp();
T Top(int index);
private:
int _top1;
int _top2;
int _len;
T* _arr;
};
template
void TwoStack::Push(int index, int data)
{
//if (_len % 2 == 0)
//{
//if (_top1>_len-2 || _top2>=_len-1)
//{
//cout << "overflow" << endl;
//return;
//}
//}
//else
//{
//if (_top1 >_len || _top2 >= _len - 2)
//{
//cout << "overflow" << endl;
//return;
//}
//}
int flag = _len % 2;
if (index == 0)
{
if (flag == 0)
{
if (_top1 >= _len - 2)
{
cout << "Stack1 overflow" << endl;
return;
}
}
if (flag == 1)
{
if (_top1 >= _len - 1)
{
cout << "overflow" << endl;
return;
}
}
////////////////////////////
if (_top1 == -1)
{
_top1 = 0;
_arr[_top1] = data;
}
else
{
_top1+=2;
_arr[_top1] = data;
}
}
/////////////////////////////////////////////////////////
else
{
if (flag == 0)
{
if (_top2 >= _len - 2)
{
cout << "Stack2 overflow" << endl;
return;
}
}
if (flag == 1)
{
if (_top2 >= _len - 1)
{
cout << "overflow" << endl;
return;
}
}
///////////////
if (_top2 == -1)
{
_top2 = 1;
_arr[_top2] = data;
}
else
{
_top2+=2;
_arr[_top2] = data;
}
}
}
template
T TwoStack::Pop(int index)
{
int ret;
if (index == 0)
{
if (_top1 < 0)
{
cout << "Stack1 is null" << endl;
return -1;
}
else
{
ret = _arr[_top1];
_top1-=2;
}
}
else
{
if (_top2 <1)
{
cout << "Stack2 is null" << endl;
return -1;
}
else
{
ret = _arr[_top2];
_top2-=2;
}
}
return ret;
}
template
bool TwoStack::IsEmpty(int index)
{
if (index == 0 && _top1 < 0)
return true;
if (index == 1 && _top2 < 0)
return true;
return false;
}
template
void TwoStack::Disp()
{
{
for (int i = 0; i < _len; i++)
{
cout << _arr[i] << " ";
}
}
}
template
T TwoStack::Top(int index)
{
if (0 == index && _top1 >= 0)
{
return _arr[_top1];
}
if (1 == index && _top2 >=1)
{
return _arr[_top2];
}
cout << "NO TOP" << endl;
exit(0);
}
void test1()
{
TwoStacks(10);
s.Push(0, 1);
s.Push(0, 2);
s.Push(0, 3);
s.Push(0, 4);
s.Push(0, 5);
//s.Push(0, 5);
s.Push(1, 6);
s.Push(1, 7);
s.Push(1, 8);
s.Push(1, 9);
s.Push(1, 10);
//s.Push(1, 10);
//cout << s.Top(1);
//cout<s(10);
s.Push(0, 1);
s.Push(0, 2);
s.Push(0, 3);
s.Push(0, 4);
s.Push(0, 5);
s.Push(1, 6);
s.Push(1, 7);
s.Push(1, 8);
s.Push(1, 9);
s.Push(1, 10);
cout << s.Pop(0)<<" ";
cout << s.Pop(0) << " ";
cout << s.Pop(0) << " ";
cout << s.Pop(0) << " ";
cout << s.Pop(0) << " ";
cout << s.Pop(1) << " ";
cout << s.Pop(1) << " ";
cout << s.Pop(1) << " ";
cout << s.Pop(1) << " ";
cout << s.Pop(1) << " ";
//cout<
一前一后向中间走：
#define  _CRT_SECURE_NO_WARNINGS
#include
using namespace std;
template
class TwoStack
{
public:
TwoStack(int size)
:_top1(-1), _top2(size), _len(size)
{  
_arr = new T[size];
}
~TwoStack()
{
if (_arr)
{
delete[] _arr;
}
}
void Push(int index, int data);
T Pop(int index);
bool IsEmpty(int index);
void Disp();
T Top(int index);
private:
int _top1;
int _top2;
int _len;
T* _arr;
};
template
void TwoStack::Push(int index, int data)
{
if (_top1 >= _top2 - 1)
{
cout << "Stack is overflow" << endl;
return; 
}
if (index == 0)
{
_top1++;
_arr[_top1] = data;
}
else
{
_top2--;
_arr[_top2] = data;
}
}
template
T TwoStack::Pop(int index)
{
int ret;
if (index == 0)
{
if (_top1 < 0)
{
cout<<"Stack1 is null"< _len)
{
cout << "Stack2 is null" << endl;
return -1;
}
else
{
ret = _arr[_top2];
_top2++;
}
}
return ret;
}   
template
bool TwoStack::IsEmpty(int index)
{
if (index == 0 && _top1 < 0)
return true;
if (index == 1 && _top2 >= _len)
return true;
return false;
}
template
void TwoStack::Disp()
{
{
for (int i = 0; i < _len; i++)
{
cout << _arr[i] << " ";
}
}
}
template
T TwoStack::Top(int index)
{
if (0 == index && _top1>=0)
{
return _arr[_top1];
}
if (1 == index && _top2 < _len)
{
return _arr[_top2];
}
cout << "NO TOP" << endl;
exit(0);
}
void test1()
{
TwoStacks(10);
s.Push(0, 1);
s.Push(0, 2);
s.Push(0, 3);
s.Push(0, 4);
s.Push(0, 5);
//s.Push(0, 5);
s.Push(1, 6);
s.Push(1, 7);
s.Push(1, 8);
s.Push(1, 9);
s.Push(1, 10);
//s.Push(1, 10);
s.Disp();
//cout << s.IsEmpty(1);
}
void test2()
{
TwoStacks(10);
s.Push(0, 1);
s.Push(0, 2);
s.Push(0, 3);
s.Push(0, 4);
s.Push(0, 5);
s.Push(1, 6);
s.Push(1, 7);
s.Push(1, 8);
s.Push(1, 9);
s.Push(1, 10);
//cout<
using namespace std;
template
class TwoStack
{
public:
	TwoStack()
		:_top1(-1), _top2(-1), _len(0), _arr(NULL), _capacity(0)
	{							  
		
	}
	~TwoStack()
	{
		if (_arr)
		{	
			delete[] _arr;
		}
	}
	void Push(int index, int data);
	T Pop(int index);
	bool IsEmpty(int index);
	void Disp();
	T Top(int index);

	void IncreaseCapcity();
private:
	int _top1;
	int _top2;
	int _len;
	T* _arr;
	int _capacity;
};

template
void TwoStack::IncreaseCapcity()
{
	int top1 = _top1;
	int top2 = _top2;
	int size = _capacity;
	_capacity = _len * 2 + 3;
	int capacity = _len * 2 + 3;
	int newlen = capacity;
	T* tmp = new T[_capacity];
	if (_arr != NULL)
	{
		for (int i = 0; i <= top1; i++)
		{
			tmp[i] = _arr[i];
		}
		for (int j = top1 + 1; j < size; j++)
		{
			tmp[--capacity] = _arr[--_len];
			--newlen;
		}
	}


	if (_arr != NULL)
	{
		delete[] _arr;
	}
	_arr = tmp;
	_len = newlen;
	_top2 = _len;

}
template
void TwoStack::Push(int index, int data)
{
	if (_top1 >= _top2 - 1)
	{
		IncreaseCapcity();
	}
	
	if (index == 0)
	{
		_top1++;
		_arr[_top1] = data;
	}
	else
	{
		_top2--;
		_arr[_top2] = data;
	}
}
template
T TwoStack::Pop(int index)
{
	int ret;
	if (index == 0)
	{
		if (_top1 < 0)
		{
			cout<<"Stack1 is null"< _len)
		{
			cout << "Stack2 is null" << endl;
			return -1;
		}
		else
		{
			ret = _arr[_top2];
			_top2++;
		}
	}
	return ret;
}								   
template
bool TwoStack::IsEmpty(int index)
{
	if (index == 0 && _top1 < 0)
		return true;
	if (index == 1 && _top2 >= _len)
		return true;
	return false;
}
template
void TwoStack::Disp()
{
	{
		for (int i = 0; i < _capacity; i++)
		{
			cout << _arr[i] << " ";
		}
	}
}

template
T TwoStack::Top(int index)
{
	if (0 == index && _top1>=0)
	{
		return _arr[_top1];
	}

	if (1 == index && _top2 < _len)
	{
		return _arr[_top2];
	}

	cout << "NO TOP" << endl;
	exit(0);
}
void test1()
{
	TwoStacks;
	s.Push(0, 1);
	s.Push(0, 2);
	s.Push(0, 3);
	s.Push(0, 4);
	s.Push(0, 5);
	//s.Push(0, 5);
	//cout << s.Pop(0) << " ";
	//cout << s.Pop(0) << " ";
	//cout << s.Pop(0) << " ";
	//cout << s.Pop(0) << " ";
	//cout << s.Pop(0) << " ";
	s.Push(1, 6);
	s.Push(1, 7);
	s.Push(1, 8);
	s.Push(1, 9);
	s.Push(1, 10);
	//s.Push(1, 10);
	s.Disp();
	//cout << s.IsEmpty(1);
}

void test2()
{
	TwoStacks;
	s.Push(0, 1);
	s.Push(0, 2);
	s.Push(0, 3);
	s.Push(0, 4);
	s.Push(0, 5);

	s.Push(1, 6);
	s.Push(1, 7);
	s.Push(1, 8);
	s.Push(1, 9);
	s.Push(1, 10);
	//cout<            
            
                            

                分享名称：一个数组实现两个栈                

                URL链接：http://myzitong.com/article/ppsoei.html
一个数组实现两个栈

其他资讯
