有关二级C栈的题

栈是后进先出的，队列是先进先出的。
出列的顺序是a2 ，a3 ，a4 ，a6， a5， a1，我们可以知道出栈的顺序也是a2 ，a3 ，a4 ，a6， a5， a1
现在的问题就成了进栈是：a1，a2，a3，a4，a5，a6
出栈是：a2，a3，a4，a6，a5，a1
计算栈的大小:
第一步： a1进栈，此时栈中元素为1。
第二步： a2进栈，此时栈中元素为2。
第三步：根据进栈出栈顺序，a2出栈，a3进栈，此时栈中元素为2。
第四步：根据进栈出栈顺序，a3出栈，a4进栈，此时栈中元素为2。
第五步：根据进栈出栈顺序，a4出栈，a5进栈，此时栈中元素为2。
第六步：根据进栈出栈顺序， a6进栈，此时栈中元素为3。
第七步：根据进栈出栈顺序，a6出栈， 此时栈中元素为2。
第八步：根据进栈出栈顺序，a5出栈， 此时栈中元素为1。
第九步：根据进栈出栈顺序，a1出栈， 此时栈中元素为0。
有此可知，栈中元素最多的时候为3个，所以栈容量至少为3。

using System;
using SystemCollectionsGeneric;
using SystemText;
namespace ConsoleApplication1
{
#region 栈类
//栈类开始
class Stack
{
int maxsize; //顺序栈的容量
Int32[] data; //数组，用于存储栈中的数据
int top; //指示栈顶
public Int32 this[int index]
{
get { return data[index]; }
set { data[index] = value; }
}
//栈容量属性
public int Maxsize
{
get
{
return maxsize;
}
set
{
maxsize = value;
}
}
//获得栈顶的属性
public int Top
{
get
{
return top;
}
}
//使用构造器初始化栈
public Stack(int size)
{
data = new Int32[size];
maxsize = size;
top = -1;
}
//求栈的长度（栈中的元素个数）
public int StackLength()
{
return top + 1;
}
//清空顺序栈
public void ClearStack()
{
top = -1;
}
//判断顺序栈是否为空
public bool IsEmpty()
{
if (top == -1)
{
return true;
}
else
{
return false;
}
}
//判断顺序栈是否为满
public bool IsFull()
{
if (top == maxsize - 1)
{
return true;
}
else
{
return false;
}
}
//入栈 *** 作
public void Push(Int32 e)
{
if (IsFull())
{
ConsoleWriteLine("栈已满！");
return;
}
data[++top] = e;
}
//出栈 *** 作，并返回出栈的元素
public object Pop()
{
object temp = null;
if (IsEmpty())
{
ConsoleWriteLine("栈为空！");
return temp;
}
//将十进制数据转化成2进制之后d栈
int num = Int32Parse(data[top]ToString());//定义10进制整型
string num2 = ConvertToString(num, 2);//将数转换成2进制的字符串形式
temp = num2;
top--;
return temp;
}
//获取栈顶数据元素
public object GetTop()
{
if (IsEmpty())
{
ConsoleWriteLine("栈为空！");
return null;
}
return data[top];
}
}
//栈类结束
#endregion
//控制台测试代码开始
class Program
{
public static void Main()
{
ConsoleWriteLine("示例以10个元素，元素值为0-10的随机整数(10进制)\n");
Stack s = new Stack(10);
Random r = new Random(); //随机生成数据
int mid;
for (int i = 0; i < 10; i++)
{
mid = (int)rNext(0, 10); //获取10~100之间的整型数据
sPush(mid); //将数据压栈
ConsoleWriteLine("将数据{0}压栈，现在栈中元素数为：{1}",
mid, sStackLength());
}
ConsoleWriteLine("\n准备将数据元素1压栈:"); //之前已经将栈填满了。再用一个数字测试能否压栈
sPush(1); //将数据1压栈
ConsoleWriteLine("栈中元素个数为：{0}", sStackLength());
ConsoleWriteLine();
for (int j = 0; j < 10; j++) //循环出栈
{
ConsoleWriteLine("现在栈中第{0}个元素d栈，该元素数据值为：{1}，该十进制数转化为2进制为：{2}", sStackLength(), s[sTop]ToString(), sPop());
}
ConsoleRead();
}
}
//控制台测试代码结束
}

/程序无大错，只是有点小错,
已有注明，我用的vc++60/
#include<stdioh>
#include<stdlibh>
#define MaxSize 100
typedef char DataType;
typedef struct
{ DataType data[MaxSize];
int top;
} SqStack;

void InitStack(SqStack s)
{
//s=(SqStack )malloc(sizeof(SqStack));这一行是没必要的，
//因为你在main中已经声明了一个SqStack
s->top=-1;
}
void ClearStack(SqStack s)
{
free(s);
}
int StackLength(SqStack s)
{
return s->top+1;
}
int StackEmpty(SqStack s)
{
if(s->top==-1)
return 1;
else
return 0;
}
int Push(SqStack s,DataType e)//去掉&
{ if(s->top==MaxSize-1)
return 0;
s->top++;
s->data[s->top]=e;
return 1;
}
int Pop(SqStack s,DataType &e) //加上&,因为这里是引用
{ if(s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;
}
int GetTop(SqStack s,DataType &e)
{ if(s->top==-1)
return 0;
e=s->data[s->top];
return 1;
}
void DispStack(SqStack s)
{ int i;
for(i=s->top;i>=0;i--)
printf("%c",s->data[i]);
printf("\n");
}
int symmetry(DataType str[])
//判断对称,主函数里没有被调用,不用看
{
int i;
DataType e;
SqStack st=NULL;//初始化
InitStack(st);
for(i=0;str[i]!='\0';i++)
{
Pop(st,e);
if(str[i]!=e)
return(0);
}
return(1);
}
void main()
{
SqStack s;
int i;
DataType a[]={'a','b','c','d','e'};
DataType e;
InitStack(&s);
for(i=0;i<sizeof(a)/sizeof(a[0]);i++)
{
if(Push(&s,a[i])==0)
{
printf("栈已满,不能进栈!");
return;
}
}
printf("出栈的元素是:");
if(Pop(&s,e)==1)
printf("%4c",e);
if(Pop(&s,e)==1)//多了一个;
printf("%4c",e);
printf("\n");
printf("当前栈顶的元素是:");
if(GetTop(&s,e)==0)
{
printf("栈为空!");
return;
}
else
printf("%4c\n",e);
if(Push(&s,'f')==0)
{
printf("栈已满,不能进栈!");
return;
}
if(Push(&s,'g')==0)
{
printf("栈已满,不能进栈!");
return;
}
printf("当前栈中的元素个数是%d",StackLength(&s));//是&
printf("元素出栈的序列是:");
while(!StackEmpty(&s)) //是&
{
Pop(&s,e); //是Pop和e
printf("%4c",e);
}
printf("\n");
}

因为第一个在定义栈的时候就已经申请了MAX个空间了，所以使用的时候就不需要再申请空间了。
ElemType data[MAX]这一句就是申请空间的 *** 作。
第二种都是指针，定义的时候没有内存的，所以使用的时候就需要分配空间。

---