只用一个数组实现两个堆栈，这是很有意思的问题。首先我们得确定栈顶，很容易想到将数组底部与数组尾部分别作为两个栈顶。然后压栈、出栈的原理是一样的，可以参考我上一篇博客。下面我说一下要注意的地方：

1、如何判断栈满？

栈满的判断可以根据两个栈顶之间的距离来判断，当栈满时必然存在top2-top1 == 1。

int ISFull(Stack S)
{
    return S->Top2 - S->Top1 == 1;
} 

2、从数组顶端压栈，栈顶是减1；从数组底部压栈，栈顶是加1；

3、从数组顶端出栈，栈顶是加1；从数组底部出栈，栈顶是减1；

C语言实现：

#include <stdio.h> 
#include <stdlib.h>

typedef struct SNode *Stack;
struct SNode{
	int *Data;
	int Top1;
	int Top2;
	int MAXSIZE;
};

Stack Create_Two_Stack(int MaxSize);
int ISFull(Stack S);
int IS1Empty(Stack S);
int IS2Empty(Stack S);
int Push(Stack S, int X, int Tag);
int Pop(Stack S, int Tag);

int main()
{
	Stack S;
	int MaxSize;
	int i;
	scanf("%d",&MaxSize);
	S = Create_Two_Stack(MaxSize);
	for(i=1;!ISFull(S);i++)
	{
		Push(S,i,1);
		Push(S,i,2);
	}
	printf("栈1：\n");
	for( ; !IS1Empty(S); ) 
		printf("%d",Pop(S,1));
	printf("\n栈2：\n");
	for( ; !IS2Empty(S); ) 
		printf("%d",Pop(S,2));
	
	return 0;
}

/* 
**	创建两个空栈 
*/ 
Stack Create_Two_Stack(int MaxSize)
{
	Stack S = (Stack)malloc(sizeof(struct SNode));
	S->Data = (int *)malloc(MaxSize*sizeof(int));
	S->Top1 = -1;				/* 栈1栈顶在数组底部-1 */ 
	S->Top2 = MaxSize;			/* 栈2栈顶在数组顶部MaxSize */ 
	S->MAXSIZE = MaxSize;
}

/*
**	判断栈满
*/
int ISFull(Stack S)
{
	return S->Top2 - S->Top1 == 1;
} 

/*	
**	判断栈1空
*/
int IS1Empty(Stack S)
{
	return	S->Top1 == -1;  
} 

/*	
**	判断栈2空
*/
int IS2Empty(Stack S)
{
	return	S->Top2 == S->MAXSIZE;  
} 

/*
**	压栈
*/ 
int Push(Stack S, int X, int Tag)
{
	if(ISFull(S))
		return 0;
	else{
		if(Tag == 1)
			S->Data[++(S->Top1)] = X;
		else
			S->Data[--(S->Top2)] = X;
		return 1;
	}
}

/* 
**	出栈
*/
int Pop(Stack S, int Tag)
{
	if(Tag == 1){
		if(IS1Empty(S))
		{
			printf("栈1空\n");
			exit(1);
		}
		else{
			return S->Data[(S->Top1)--];
		}
	}
	else{
		if(IS2Empty(S))
		{
			printf("栈2空\n");
			exit(1);
		}
		else{
			return S->Data[(S->Top2)++];
		}
	}
}