top为指针且指针指向栈顶元素
 
 一、栈的动态分配顺序存储的结构定义：
 
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

#define ERROR 0
#define OK    1

#define INIT_SIZE  10      /*栈的初始分配容量*/ 
#define INCREMENT   2      /*栈的分配量增量*/ 

typedef int  Status;
typedef int  Elemtype;
typedef struct SqStack{
	Elemtype *base;       //栈底指针，始终指向栈底的位置 
	Elemtype *top;        //栈定指针，可以指向栈顶元素下一个位置或栈顶元素 
	int StackSize;        //栈的初始可使用分配存储量 
}SqStack;
 
二、栈的初始化：
 
/*栈的动态分配顺序存储初始化,且top指针指向栈顶元素 */
Status InitStack(SqStack *S)
{
	S->base=(Elemtype*)malloc(sizeof(Elemtype)*INIT_SIZE);
	if(!S->base)
	{
		return ERROR;
	}
	S->top = S->base-1;            
	S->StackSize=INIT_SIZE;
	return OK;
}
 
三、入栈（压栈）操作：
 
/*压栈操作*/ 
void PushStack(SqStack *S,Elemtype e)
{
	
	if( S->top - S->base + 1 >= S->StackSize )
	{   /*栈满，追加空间*/
		S->base=(Elemtype*)realloc(S->base,(S->StackSize+INCREMENT)*sizeof(Elemtype));
	    assert(S->base != NULL);                //判断是否扩容成功 
		S->top = S->base + S->StackSize -1;    //修改栈顶指针 
		S->StackSize=S->StackSize+INCREMENT;   //扩容后栈的存储容量 
	}
	
	*++S->top=e;                               //将e入栈 
} 
 
四、栈的当前长度：
 
/*栈的当前长度*/
Status StackLength(SqStack *S)
{
	if( S->top >= S->base -1 )
	{
		return S->top - S->base +1;
	} 
	else return ERROR;
}
 
五、获取栈顶元素：
 
/*取栈顶元素*/
Status GetTop(SqStack *S,Elemtype *e)
{
	if(S->top > S->base -1 )
	{
		*e = *S->top;
		return OK;
	}
	else return ERROR;
} 
 
六、判断栈是否为空栈：
 
/*判断一个栈是否为空*/
Status StackEmpty(SqStack *S)
{
	if( S->top == S->base - 1 ) return ERROR;
	else return OK;
} 

 
七、清空栈：
 
/*清空栈*/
void ClearStack(SqStack *S)
{
	S->top = S->base-1;
} 
 
八、销毁栈：
 
/*销毁栈*/
void DestroyStack(SqStack *S)
{
	if(S != NULL)
	{
		free(S->base);
		S->base = S->top=NULL;
		S->StackSize=0;
	}
}
 
九、出栈（弹栈）操作：
 
/*弹栈操作*/
Status PopStack(SqStack *S,Elemtype *e)
{
	if(S->top == S->base -1)    //判断是否栈空 
	{
		return ERROR;
	}
	*e = *S->top--;
	return OK;
}
 
十、遍历栈：
 
/*遍历栈*/ 
void StackTraverse(SqStack S,void (*visit)(Elemtype))
{
	while(StackEmpty(&S))
	{
		visit(*S.base++);
	}
}
void Print(Elemtype e)
{
	printf("%d ",e);
}
 
十一、主函数：
 
int main()
{
	int i,value,length;
	Elemtype e;
	SqStack S;
	
	value=InitStack(&S);
	if(value)
	{
		printf("初始化栈成功！\n\n");
	}
	else  
	{
		puts("error!");
		return ERROR;
	}
	
	for(i=1;i<12;i++)
	PushStack(&S,i);
	printf("栈中的元素为：\n");
	StackTraverse(S,Print);
	
	value=StackEmpty(&S);
	if(value)
	{
		printf("\n非空栈！\n");
	}
	else
	{
		printf("空栈！");
	} 
	length=StackLength(&S);
	printf("当前长度为：%d\n",length);
	
	value=PopStack(&S,&e);
	if(value)
	{
		printf("\n弹出的栈顶元素为：%d\n",e);
	}
	else
	{
		printf("空栈！\n");
		return ERROR;
	}	
		
	value=GetTop(&S,&e);
	if(value)
	{
		printf("当前栈顶元素为：%d\n当前栈长度为：%d\n",e,StackLength(&S));
	} 
	else
	{
		printf("error! Stack Empty\n");
		return ERROR;
	} 
	
	ClearStack(&S);
	printf("\n\n清空栈后：\n");
	value=StackEmpty(&S);
	if(value)
	{
		printf("\n非空栈！");
	}
	else
	{
		printf("空栈！\n");
	} 
	length=StackLength(&S);
	printf("当前长度为：%d\n",length);
	
	DestroyStack(&S);
	printf("\n销毁栈后：\n top=%u,base=%u,StackSize=%d",S.top,S.base,S.StackSize);
	
	return 0;
} 
 
十二、运行截图：
 

理解静态栈中的top指针
 
对于顺序静态栈定义代码：
 
typedef struct Stack
 {
 int s[10];
 int top;
 } stack;
 
在C语言数据结构教材中常提到 ： top指针，但是在top指针里面存放的是一个整型数据，需要注意的是，此指针而非C语言里面的指针，C语言中的指针是存放的指向下一个数据元素的地址。
 
在栈式存储中，定义的结构体类型在内存中的分配是这样的：
 
 如上图的内存分配：top是一个整型的变量，里面存放的是整型值，而非地址，但是为什么在数据结构中还是叫它top指针呢？
 首先先来思考一个问题：栈是怎么一步步的向里面存放数据的的呢？在顺序静态栈中的定义上，提前固定了数组的大小， 初始的时候，我们先要使数组的角标为 0，然后向S[ 0 ]进行赋值，之后再使数组的角标加 1，然后向 S[ 1 ]输入数据，依次如此向下进行。直到输入至角标为 9 时，此时为S[ 9 ],栈满。
 说了这么多有啥用呢。。你品，你细品；难道top不就是像极了角标吗？
 在栈的初始化中代码描述不是这样的吗：
 
void Initiazation (stack &S)
 {
 S.top=0;
 }
 我们对栈中的 top 变量进行了初始化，每当我们向栈中第一次添加数据时，只需要使用 数组名[ S.top ]=添加的数据，也就是S. s[ S.top ]=数据，然后再使 S.top++;如此就可以依次向下继续添加数据，直到栈满；
 在内存中top的变化是这样的：
 
 
但是呢，可以这么理解top： top=0时，对应的数组角标为0；也就可以理解为：top=0时指向角标为0的数组，如果向栈中添加数据，只需要向角标为top值的数组添加数据即可；换言之：top就是能够使数组依次添加数据的中间量，每一次添加数据，都使用top值作为数组的角标，进行数据的添加，所以top值对应着为相同角标的数组位置，故而有着top指针的称谓。
 
再来看一下压栈代码：
 
  void PushStack (stack &S,int e)
   { 
         S.s[S.top]=e;  //先向top所指向的数组进行赋值，值为e；
         S.top++;       //再使top值加1，使其指向下一个数组位置
   }
 
所以这样的解释，应该很好理解“为什么栈中的top是整型数值，但还是把它叫做指针了吧。。。”

栈是先进后出的结构体，栈顶指针有两种情况 1，栈顶指针指向的是空的位置 2.栈顶指针指向栈顶的数据
 
第一种情况：当栈顶指针指向的是一个空位置。当栈不为空的时候 想出栈时候，系统得知道哪个数据出栈，此时指向栈顶的指针需要向下移动一个单元告诉系统即将出栈的数据的位置。 当数据需要进栈时候，系统需要知道数据放在哪个位置，此时指针指向的是一个空单元，所以数据先入栈，然后指针再移动。
 
第二种情况：当栈顶指针指向的是一个实际数据。当栈不为空时，当数据想出栈，此时指针指向的正好是即将出栈的数据，指针告诉了系统这个数据的位置，因此先将数据出栈，然后移动指针。 当数据想进栈时候，系统需要知道数据放的位置。此时指针指向的位置已经有数据了，因此需要先移动告诉系统数据放的位置然后数据再入栈
 
指针不论指向空位置还是指向一个非空的存放实际数据的位置，指针的移动核心都是让系统知道从哪个位置取数据，或者在哪个位置放数据。

top为指针且指向栈顶元素下一个位置
 
 一、栈的动态分配顺序存储结构定义：
 
#include<stdio.h>
#include<stdlib.h>

#define ERROR 0
#define OK    1

#define INIT_SIZE  10      /*栈的初始分配容量*/ 
#define INCREMENT   2      /*栈的分配量增量*/ 

typedef int  Status;
typedef int  Elemtype;
typedef struct SqStack{
	Elemtype *base;       //栈底指针，始终指向栈底的位置 
	Elemtype *top;        //栈顶指针，可以指向栈顶元素下一个位置或栈顶元素 
	int StackSize;        //栈的初始可使用分配存储量 
}SqStack;
 
二、栈的初始化：
 
/*栈的动态分配顺序存储初始化,且栈顶指针且指向下一个栈顶元素 */
Status InitStack(SqStack *S)
{
	S->base=(Elemtype*)malloc(sizeof(Elemtype)*INIT_SIZE);
	if(!S->base)
	{
		return ERROR;
	}
	S->top=S->base;            
	S->StackSize=INIT_SIZE;
	return OK;
}
 
三、入栈（压栈）操作：
 
/*压栈操作*/ 
Status PushStack(SqStack *S,Elemtype e)
{
	
	if( S->top - S->base >= S->StackSize )
	{   /*栈满，追加空间*/
		S->base=(Elemtype*)realloc(S->base,(S->StackSize+INCREMENT)*sizeof(Elemtype));
		if(!S->base)                           //扩容失败 
		{
			return ERROR;
		}
		S->top=S->StackSize+S->base;           //修改栈顶指针 
		S->StackSize=S->StackSize+INCREMENT;   //扩容后栈的存储容量 
	}
	*(S->top)=e;                               //将e入栈 
	S->top++;                                  //入栈后栈顶指针指向下一个栈顶元素的地址 
	return OK;
} 
 
四、栈的当前长度：
 
/*栈的当前长度*/
Status StackLength(SqStack *S)
{
	if(S->base != NULL && S->top != NULL )
	{
		return S->top - S->base;
	} 
	else return ERROR;
}
 
五、取栈顶元素：
 
/*取栈顶元素*/
Status GetTop(SqStack *S,Elemtype *e)
{
	if(S->top > S->base)
	{
		*e = *(S->top-1);
		return OK;
	}
	else return ERROR;
} 
 
六、判断一个栈是否为空：
 
/*判断一个栈是否为空*/
Status StackEmpty(SqStack *S)
{
	if(S->base==S->top) return ERROR;
	else return OK;
} 
 
七、清空栈：
 
/*清空栈*/
void ClearStack(SqStack *S)
{
	S->top=S->base;
} 
 
八、销毁栈：
 
/*销毁栈*/
void DestroyStack(SqStack *S)
{
	if(S != NULL)
	{
		free(S->base);
		S->top=S->base=NULL;
		S->StackSize=0;
	}
}
 
九、出栈（弹栈）操作：
 
/*弹栈操作*/
Status PopStack(SqStack *S,Elemtype *e)
{
	if(S->top == S->base)    //判断是否栈空 
	{
		return ERROR;
	}
	*e = *--S->top;
	return OK;
}
 
十、遍历栈：
 
/*遍历栈*/ 
void StackTraverse(SqStack S,void (*visit)(Elemtype))
{
	while(StackEmpty(&S))
	{
		visit(*S.base++);
	}
}
void Print(Elemtype e)
{
	printf("%d ",e);
}
 
十一、主函数：
 
int main()
{
	int i,value,length;
	Elemtype e;
	SqStack S;
	
	value=InitStack(&S);
	if(value)
	{
		printf("初始化栈成功！\n\n");
	}
	else  
	{
		puts("error!");
		return ERROR;
	}
	
	for(i=1;i<10;i++)
	PushStack(&S,i);
	printf("栈中的元素为：\n");
	StackTraverse(S,Print);
	
	value=StackEmpty(&S);
	if(value)printf("\n非空栈！");
	else printf("空栈！");
	length=StackLength(&S);
	printf("当前长度为：%d\n",length);
	
	PopStack(&S,&e);
	printf("\n弹出的栈顶元素为：%d\n",e);
	GetTop(&S,&e);
	printf("新的栈顶元素为：%d\n当前栈长度为：%d\n",e,StackLength(&S));
	
	ClearStack(&S);
	printf("\n\n清空栈后：\n");
	length=StackLength(&S);
	printf("当前长度为：%d\n",length);
	
	DestroyStack(&S);
	printf("\n销毁栈后：\n top=%u,base=%u,StackSize=%d",S.top,S.base,S.StackSize);
	
	return 0;
} 
 
十二、运行效果截图：