小蚂蚁学习数据结构（28）——题目——顺序栈的遍历输出

已知栈的顺序存储结构定义如下：

typedef int SElemType;

typedef struct{

SElemType * base;

SElemType * top;

int stacksize;

}SqStact;

下面是依次弹出栈中的所有元素、并逐个输出的类C_算法，操作的结果使栈变成空栈，请填空

void Pop_Print_Sq(SqStack &S);

/*
顺序栈的操作
题目要求：依次弹出栈中元素、并逐个输出的类C算法。
*/
# include <stdio.h>
# include <malloc.h>

# define ERROR 0
# define OK	   1
# define STACK_INIT_SIZE 5
# define STACKINCREMENT  1

typedef char Elemtype;
typedef int  Status;

typedef struct stack
{
Elemtype * base;	//栈底指针
Elemtype * top;		//栈顶指针
int stacksize;		//栈总空间
}SqStack;

//栈操作函数前置声明
//初始化一个栈
Status InitStack( SqStack & );
//销毁这个栈
Status DestroyStack( SqStack & );
//清空这个栈
Status ClearStack( SqStack & );
//判断这个栈是否为空
bool StackEmtpy( SqStack & );
//返回这个栈的长度
Status StackLength( SqStack & );
//得到栈顶元素
Status GetTop( SqStack &, Elemtype & );
//往栈中压入一个元素
Status Push( SqStack &, Elemtype );
//弹出一个元素，并且返回弹出元素的值
Status Pop( SqStack &, Elemtype & );
//遍历整个栈
Status StackTraverse( SqStack & );
//题目要求的函数
void Pop_Print_Sq( SqStack & );

//初始化这个栈
Status InitStack( SqStack & S )
{
/*
为栈指针分配空间
PS：malloc分配空间这里，超出后也正常的原因需要重点标注一下。
*/
S.base = ( Elemtype * )malloc( sizeof( Elemtype ) * STACK_INIT_SIZE );
if( NULL == S.base )
{
printf( "动态空间分配失败\n" );
return ERROR;
}
S.top = S.base;
S.stacksize = STACK_INIT_SIZE;

return OK;
}

//向栈中压入一个元素
Status Push( SqStack & S, Elemtype val)
{

if( S.top - S.base >= S.stacksize )
{
//如果存储空间已满，就需要增加新的空间
S.base = ( Elemtype * )realloc( S.base, ( S.stacksize + STACKINCREMENT ) * sizeof( Elemtype ) );
if( NULL == S.base )
{
printf( "动态空间分配失败\n" );
return ERROR;
}
/*
重新设定栈顶指针top，因为之前top指向的是一个不属于自己的空间，
现在新开辟了一个属于自己的空间，所以重新指定一下
万一地址换了也是有可能的！
*/
S.top = S.base + S.stacksize;
//修改结构体中，空间的总大小
S.stacksize = S.stacksize + STACKINCREMENT;
}

*S.top = val;
S.top++;
return OK;
}

//遍历整个栈
Status StackTraverse( SqStack & S )
{
if( S.top == S.base )
{
return ERROR;
}
else
{
Elemtype * p = S.base;
while( p != S.top )
{
printf( "%c ", *p );
p++;
}
printf( "\n" );

return OK;
}
}

//判断这个栈是否为空
bool StackEmtpy( SqStack & S )
{
if( S.top == S.base )
{
return true;
}
else
{
return false;
}
}

//返回这个栈的长度
int StackLength( SqStack & S )
{
return S.top - S.base;
}

//返回栈顶元素
Status GetTop( SqStack & S, Elemtype & c )
{
if( S.top == S.base )
{
return ERROR;
}
else
{
c = *(S.top-1);
}
}

//弹出一个元素，并且返回弹出元素的值
Status Pop( SqStack & S, Elemtype & c )
{
if( S.top == S.base )
{
return ERROR;
}
else
{
c = *(S.top-1);
S.top--;
S.stacksize--;
}
}

//清空这个栈
Status ClearStack( SqStack & S )
{
S.top = S.base;
return OK;
}

//销毁这个栈
Status DestroyStack( SqStack & S )
{
//释放栈空间
free( S.base );
//初始化栈结构体
S.top  = NULL;
S.base = NULL;
S.stacksize = 0;

return OK;
}

/*
题目要求的函数
题目貌似没有说是从上往下遍历，还是从下往上遍历
*/
void Pop_Print_Sq( SqStack & S )
{
while( S.top != S.base )
{
S.top--;
printf( "%c ", *S.top );
}
}

int main( void )
{
char c;
//创建一个栈
SqStack STA;
//初始化这个栈
InitStack( STA );
//为栈中压入一个元素
Push( STA, 'a' );
Push( STA, 'b' );
Push( STA, 'c' );
Push( STA, 'd' );
Push( STA, 'e' );
Push( STA, 'f' );
Push( STA, 'g' );
Push( STA, 'h' );
Push( STA, 'i' );
Push( STA, 'j' );
Push( STA, 'k' );
//遍历这个栈
printf( "压入元素从a~k，遍历这个栈：\n" );
StackTraverse( STA );

printf( "判断这个栈是否为空？" );
if( StackEmtpy( STA ) )
{
printf( "这个栈为空\n" );
}
else
{
printf( "这个栈不为空\n" );
}

printf( "该链表的长度为：%d\n", StackLength( STA ) );

GetTop( STA, c );
printf( "目前栈顶元素为：%c\n", c );

Pop( STA, c );
printf( "弹出的栈顶元素为：%c\n此刻的栈中元素是：", c );
StackTraverse( STA );

//题目要求的函数
printf( "依次弹出栈中元素、并将栈清空：\n" );
Pop_Print_Sq( STA );
StackTraverse( STA );
printf( "\n" );
//清空这个栈
ClearStack( STA );
StackTraverse( STA );

//销毁这个栈
DestroyStack( STA );

return 0;
}
/*
VC++6.0输出的结果是
========================================
压入元素从a~k，遍历这个栈：
a b c d e f g h i j k
判断这个栈是否为空？这个栈不为空
该链表的长度为：11
目前栈顶元素为：k
弹出的栈顶元素为：k
此刻的栈中元素是：a b c d e f g h i j
依次弹出栈中元素、并将栈清空：
j i h g f e d c b a
========================================
总结：
整体上没有什么难度，之前写过链表的栈，趁着这个机会把顺序栈也
练习一下。在malloc那里有点迷糊了，由于字数比较多，就在下面单独
总结吧。
*/

学PHP的小蚂蚁 博客 http://my.oschina.net/woshixiaomayi/blog