Chapter 3 | Stacks and Queues--一个数组实现三个栈（续）

针对上篇博文中方法二的问题，这里我们提供一个方法来解决所出现的空间浪费的问题

上篇博文见：一个数组实现三个栈(1)

方法二加强版：下面就针对这个问题对程序进行进一步的修改。

1、每次 pop 出栈之后，检查压出元素位置是否小于当前数组总索引，如果是，则将总索引指向压出元素位置，就是指向刚弹出后留下的空位置，否则表示总索引位置在压出元素位置之前，那么就不需要进行处理；

2、每次 push 压栈后，都需要从数组始端开始遍历数组，寻找第一个空位置，然后将索引指向该空位置。

PS：需要注意的是，数组总索引并不是指向数组的最后位置，而是指向数组空间的第一个空位置。

具体见程序，相比前面那个程序，这里在结构体中添加了一个判断标志

typedef struct _Stack
{
	int value;            //当前元素
	int preIndex;         //上一个元素的索引
	bool isFree = true;          //判断是否为空
}Stack;

int totalSize = 10;
int stackPointer[] = { -1, -1, -1 };
int indexCur = 0;

Stack *buffer = new Stack[totalSize];

/*
	每个栈必须维护其各自的栈顶位置以及其栈顶的前一个位置，
	后者保证出栈之后，栈顶位置时刻指向栈顶元素
*/

bool push(int stackNum, int value)
{
	if (indexCur == totalSize)         //“总栈”溢出
		return false;

	/*第stackNum栈的前一个元素位置，就是压栈之前的栈顶位置*/
	int lastIndex = stackPointer[stackNum];       
	stackPointer[stackNum] = indexCur;          //第stackNum栈的栈顶指针指向空位置
	
	buffer[stackPointer[stackNum]].value = value;             //stackNum栈的栈顶元素
	buffer[stackPointer[stackNum]].isFree = false;            //该位置非空
	buffer[stackPointer[stackNum]].preIndex = lastIndex;      //指向前一个元素的索引
															  //通过索引建立元素栈关系
	/*每次压栈后从数组始端开始寻找空位置，即下次压栈位置*/
	int pos = 0;                                              
	while (!buffer[pos].isFree)                                
	{
		++pos;
		indexCur = pos;
	}

	return true;
}

bool pop(int stackNum, int *value)
{
	if (-1 == stackPointer[stackNum])
		return false;

	*value = buffer[stackPointer[stackNum]].value;    //返回第stackNum栈的栈顶元素

	int lastIndex = stackPointer[stackNum];           //记录当前出栈位置(未出栈时栈顶位置)
	                                                  //出栈后为空
	
	/*弹出位置小于数组总索引，则将总索引指向空位置，弹出位置大于总索引，则不处理*/
	if (lastIndex < indexCur)                         
		indexCur = lastIndex;						  
	                                  
	/*第stackNum栈的栈顶“指针”指向当前栈顶的前一个位置，出栈之后，该位置替换为栈顶位置*/
	stackPointer[stackNum] = buffer[stackPointer[stackNum]].preIndex;

	/*这里设定一个标志为空，表明该位置可压入元素*/
	buffer[lastIndex].isFree = true;

	return true;
}

bool isEmpty(int stackNum)
{
	return (-1 == stackPointer[stackNum]);
}

我们同样采用上一篇的测试程序，多添加了验证空间可用程序，再贴一下

int main()
{
	int value0, value1, value2;
	for (int i = 0; i < 3; ++i)
	{
		if (!push(0, i) || !push(1, i+3))
			break;
	}

	for (int i = 0; i < 3; ++i)
	{
		if (!pop(0, &value0))
			break;
	}
	
	for (int i = 0; i < 3; ++i)
	{
		if (!push(2, i+6))
			break;
	}

	/*验证空间可用，额外添加*/
	for (int i = 0; i < 3; ++i)
	{
		if (!push(0, 10))
			break;
	}

	for (int i = 0; i < 9; ++i)
		cout << buffer[i].value << endl;
	return 0;
}

也照例分析一下：

第一个 for 循环：两个栈压栈之后，数组空间里的元素分布为：0 , 3 , 1 , 4 , 2 , 5。其中 Stack_0 为0,1,2； Stack_1 为3,4,5。

第二个 for 循环：Stack_0出栈，腾出了空间，虽然数组空间元素分布依旧是 0 , 3 , 1 , 4 , 2 , 5， 但是总索引 indexCur 指向了 数组空间的第一个空余位置

第三个 for 循环：Stack_2 压栈，压入上一个 pop 腾出的空位置，这样数组空间元素为 6 , 3 , 7 , 4 , 8 , 5。

第四个 for 循环是额外添加的，验证压栈利用了空间。

测试结果